def handle_request(self, req, client, addr): try: self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, client, addr, self.address, self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False respiter = self.wsgi(environ, resp.start_response) try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() finally: if hasattr(respiter, "close"): respiter.close() except socket.error: # We want to ignore connection reset by peer errors since these # are non-fatal and handled by the reverse proxy if getattr(socket, 'code', None) == 54: return raise except Exception, e: # Only send back traceback in HTTP in debug mode. self.handle_error(client, e) return
def handle_request(self, req, sock, addr): try: self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, sock, addr, self.address, self.cfg) self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False respiter = self.wsgi(environ, resp.start_response) if respiter == ALREADY_HANDLED: return False try: for item in respiter: resp.write(item) resp.close() finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): raise StopIteration() except StopIteration: raise except Exception, e: #Only send back traceback in HTTP in debug mode. self.handle_error(sock, e) return False
def handle_request(self, listener_name, req, sock, addr): request_start = datetime.now() environ = {} resp = None try: self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, sock, addr, listener_name, self.cfg) environ["wsgi.multithread"] = True self.nr += 1 if self.nr >= self.max_requests: if self.alive: self.log.info( "Autorestarting worker after current request.") self.alive = False if not self.alive or not self.cfg.keepalive: resp.force_close() respiter = self.wsgi(environ, resp.start_response) if self.is_already_handled(respiter): return False try: if isinstance(respiter, environ["wsgi.file_wrapper"]): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): raise StopIteration() except StopIteration: raise except EnvironmentError: # If the original exception was a socket.error we delegate # handling it to the caller (where handle() might ignore it) util.reraise(*sys.exc_info()) except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. self.log.exception("Error handling request") try: sock.shutdown(socket.SHUT_RDWR) sock.close() except EnvironmentError: pass raise StopIteration() raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook") return True
def handle_request(self, req, client, addr): environ = {} try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, client, addr, self.address, self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False respiter = self.wsgi(environ, resp.start_response) try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() except socket.error: raise except Exception, e: # Only send back traceback in HTTP in debug mode. self.handle_error(client, e) return
def handle_request(self, req, sock, addr): try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, sock, addr, self.address, self.cfg) self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False respiter = self.wsgi(environ, resp.start_response) if respiter == ALREADY_HANDLED: return False try: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): raise StopIteration() finally: try: self.cfg.post_request(self, req, environ) except: pass return True
def handle_request(self, req, client, addr): try: debug = self.cfg.debug or False self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, client, addr, self.address, self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False respiter = self.wsgi(environ, resp.start_response) for item in respiter: resp.write(item) resp.close() if hasattr(respiter, "close"): respiter.close() except socket.error: raise except Exception, e: # Only send back traceback in HTTP in debug mode. self.handle_error(client, e) return
def handle_request(self, req, sock, addr): try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, sock, addr, self.address, self.cfg) self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False respiter = self.wsgi(environ, resp.start_response) if respiter == ALREADY_HANDLED: return False try: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): raise StopIteration() finally: try: self.cfg.post_request(self, req, environ) except: pass return True
def handle_request(self, req, sock, addr): try: self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, sock, addr, self.address, self.cfg) self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False respiter = self.wsgi(environ, resp.start_response) if respiter == ALREADY_HANDLED: return False for item in respiter: resp.write(item) resp.close() if hasattr(respiter, "close"): respiter.close() if req.should_close(): raise StopIteration() except StopIteration: raise except Exception, e: # Only send back traceback in HTTP in debug mode. self.handle_error(sock, e) return False
def handle_request(self, req, client, addr): try: debug = self.cfg.debug or False self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, client, addr, self.address, self.cfg) self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False respiter = self.wsgi(environ, resp.start_response) for item in respiter: resp.write(item) resp.close() if hasattr(respiter, "close"): respiter.close() self.cfg.post_request(self, req) except socket.error: raise except Exception, e: # Only send back traceback in HTTP in debug mode. if not self.debug: raise util.write_error(client, traceback.format_exc()) return
def handle_request(self, listener_name, req, sock, addr): request_start = datetime.now() environ = {} resp = None try: self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, sock, addr, listener_name, self.cfg) environ["wsgi.multithread"] = True self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False if not self.cfg.keepalive: resp.force_close() respiter = self.wsgi(environ, resp.start_response) if respiter == ALREADY_HANDLED: return False try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) except socket.error as e: # BROKEN_SOCK not interesting here if not get_errno(e) in BROKEN_SOCK: raise finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): raise StopIteration() except StopIteration: raise except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. self.log.exception("Error handling request") try: sock.shutdown(socket.SHUT_RDWR) sock.close() except socket.error: pass raise StopIteration() raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook") return True
def handle_request(self, listener_name, req, sock, addr): request_start = datetime.now() environ = {} resp = None try: self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, sock, addr, listener_name, self.cfg) environ["wsgi.multithread"] = True self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False if not self.cfg.keepalive: resp.force_close() respiter = self.wsgi(environ, resp.start_response) if self.is_already_handled(respiter): return False try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): raise StopIteration() except StopIteration: raise except EnvironmentError: # If the original exception was a socket.error we delegate # handling it to the caller (where handle() might ignore it) util.reraise(*sys.exc_info()) except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. self.log.exception("Error handling request") try: sock.shutdown(socket.SHUT_RDWR) sock.close() except EnvironmentError: pass raise StopIteration() raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook") return True
def handle_request(self, listener, req, client, addr): environ = {} resp = None try: # 钩子函数 self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, client, addr, listener.getsockname(), self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 """`max_requests` -- The maximum number of requests a worker will process before restarting. """ if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False # 调用web应用对象去处理请求 respiter = self.wsgi(environ, resp.start_response) try: # 输出响应 if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() except EnvironmentError: # pass to next try-except level util.reraise(*sys.exc_info()) except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. self.log.exception("Error handling request") try: client.shutdown(socket.SHUT_RDWR) client.close() except EnvironmentError: pass raise StopIteration() raise finally: try: # 钩子函数 self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook")
def handle_request(self, listener, req, client, addr): environ = {} resp = None try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req=req, sock=client, client=addr, server=listener.getsockname(), cfg=self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. todo: 不懂 resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Auto restarting worker after current request.") self.alive = False respiter = self.wsgi(environ, resp.start_response) try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() except EnvironmentError: # pass to next try-except level util.reraise(*sys.exc_info()) except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should # close the connection to indicate the error. self.log.exception("Error handling request") try: # Shut down one or both halves of the connection # SHUT_RDWR: further sends and receives are disallowed client.shutdown(socket.SHUT_RDWR) client.close() except EnvironmentError: pass raise StopIteration() raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook")
def handle_request(self, listener, req, client, addr): environ = {} resp = None try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, client, addr, listener.getsockname(), self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False respiter = self.wsgi(environ, resp.start_response) try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() except socket.error: raise except Exception as e: if resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. try: client.shutdown(socket.SHUT_RDWR) client.close() except socket.error: pass return # Only send back traceback in HTTP in debug mode. self.handle_error(req, client, addr, e) return finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook")
def handle_request(self, listener, req, client, addr): environ = {} resp = None try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, client, addr, listener.getsockname(), self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False respiter = self.wsgi(environ, resp.start_response) try: if environ.has_key('wsgi.file_wrapper') and isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() except socket.error: raise except Exception as e: if resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. try: client.shutdown(socket.SHUT_RDWR) client.close() except socket.error: pass return # Only send back traceback in HTTP in debug mode. self.handle_error(req, client, addr, e) return finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook")
def handle_request(self, listener, req, client, addr): environ = {} resp = None try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, client, addr, listener.getsockname(), self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False respiter = self.wsgi(environ, resp.start_response) try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() except socket.error: exc_info = sys.exc_info() # pass to next try-except level six.reraise(exc_info[0], exc_info[1], exc_info[2]) except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. self.log.exception("Error handling request") try: client.shutdown(socket.SHUT_RDWR) client.close() except socket.error: pass raise StopIteration() raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook")
def handle_request(self, listener, req, sock, addr): request_start = datetime.now() environ = {} resp = None try: self.cfg.pre_request(self, req) resp, environ = wsgi.create(req, sock, addr, listener.getsockname(), self.cfg) self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False if not self.cfg.keepalive: resp.force_close() respiter = self.wsgi(environ, resp.start_response) if respiter == ALREADY_HANDLED: return False try: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): raise StopIteration() except Exception: if resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. try: sock.shutdown(socket.SHUT_RDWR) sock.close() except socket.error: pass return raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook") return True
def handle_request(self, req, client, addr): try: debug = self.cfg.debug or False resp, environ = wsgi.create(req, client, addr, self.address, self.cfg) respiter = self.wsgi(environ, resp.start_response) for item in respiter: resp.write(item) resp.close() if hasattr(respiter, "close"): respiter.close() except socket.error: raise except Exception, e: # Only send back traceback in HTTP in debug mode. if not self.debug: raise util.write_error(client, traceback.format_exc()) return
def handle_request(self, req, sock, addr): try: debug = self.cfg.debug or False resp, environ = wsgi.create(req, sock, addr, self.address, debug) respiter = self.wsgi(environ, resp.start_response) if respiter == ALREADY_HANDLED: return False for item in respiter: resp.write(item) resp.close() if hasattr(respiter, "close"): respiter.close() if req.should_close(): raise StopIteration() except Exception, e: #Only send back traceback in HTTP in debug mode. if not self.debug: raise util.write_error(sock, traceback.format_exc()) return False
def handle_request(self, req, conn): environ = {} resp = None try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, conn.sock, conn.addr, conn.listener.getsockname(), self.cfg) environ["wsgi.multithread"] = True self.nr += 1 if self.alive and self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") resp.force_close() self.alive = False if not self.cfg.keepalive: resp.force_close() respiter = self.wsgi(environ, resp.start_response) try: if isinstance(respiter, environ['wsgi.file_wrapper']): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() if resp.should_close(): self.log.debug("Closing connection.") return False except socket.error: exc_info = sys.exc_info() # pass to next try-except level six.reraise(exc_info[0], exc_info[1], exc_info[2]) except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. self.log.exception("Error handling request") try: conn.sock.shutdown(socket.SHUT_RDWR) conn.sock.close() except socket.error: pass raise StopIteration() raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook") return True
def handle_request(self, listener, req, client, addr): environ = {} resp = None try: self.cfg.pre_request(self, req) request_start = datetime.now() resp, environ = wsgi.create(req, client, addr, listener.getsockname(), self.cfg) # Force the connection closed until someone shows # a buffering proxy that supports Keep-Alive to # the backend. resp.force_close() self.nr += 1 if self.nr >= self.max_requests: self.log.info("Autorestarting worker after current request.") self.alive = False use_cache = False cache_key = "{0}:{1}".format(req.uri, req.method) for route in self.cache_route: if re.match(route["url"], req.uri) and req.method in route["methods"]: use_cache = True if environ.get("HTTP_GUNICORN_CACHE_REFRESH"): result = None else: result = self.redis.get(cache_key) if not result: respiter = self.wsgi(environ, resp.start_response) if resp.status_code == 200: result = {"body": [x for x in respiter], "headers": resp.headers} self.redis.set(cache_key, pickle.dumps(result), route.get("expire", 300)) else: result = pickle.loads(result) if resp.status is None: resp.start_response("200 OK", result["headers"]) respiter = result["body"] if route.get("prolong", True): self.redis.expire(cache_key, route.get("expire", 300)) break if not use_cache: respiter = self.wsgi(environ, resp.start_response) try: if isinstance(respiter, environ["wsgi.file_wrapper"]): resp.write_file(respiter) else: for item in respiter: resp.write(item) resp.close() request_time = datetime.now() - request_start self.log.access(resp, req, environ, request_time) finally: if hasattr(respiter, "close"): respiter.close() except socket.error: exc_info = sys.exc_info() # pass to next try-except level six.reraise(exc_info[0], exc_info[1], exc_info[2]) except Exception: if resp and resp.headers_sent: # If the requests have already been sent, we should close the # connection to indicate the error. self.log.exception("Error handling request") try: client.shutdown(socket.SHUT_RDWR) client.close() except socket.error: pass raise StopIteration() raise finally: try: self.cfg.post_request(self, req, environ, resp) except Exception: self.log.exception("Exception in post_request hook")