def wrapper(request, response): req = yield request.read() datas = yield application(WSGIContainer.environ(req), functools.partial(start_response, response)) for data in datas: response.write(data) response.close()
def __init__(self, tornado_req, site_conf): super(TornadoRequest, self).__init__( WSGIContainer.environ(tornado_req) ) self._native_request = tornado_req self.site = site_conf
def get(self): from tornado.wsgi import WSGIContainer from django.core.handlers.wsgi import WSGIRequest, get_script_name import urllib environ = WSGIContainer.environ(self.request) environ['PATH_INFO'] = urllib.unquote(environ['PATH_INFO']) request = WSGIRequest(environ) request._tornado_handler = self set_script_prefix(get_script_name(environ)) signals.request_started.send(sender=self.__class__) try: response = self.get_response(request) if not response: return finally: signals.request_finished.send(sender=self.__class__) self.set_status(response.status_code) for h in response.items(): self.set_header(h[0], h[1]) if not hasattr(self, "_new_cookies"): self._new_cookies = [] self._new_cookies.append(response.cookies) self.write(response.content) self.finish()
def get(self, *args, **kwargs): # type: (*Any, **Any) -> None environ = WSGIContainer.environ(self.request) environ['PATH_INFO'] = urllib.parse.unquote(environ['PATH_INFO']) request = WSGIRequest(environ) request._tornado_handler = self set_script_prefix(get_script_name(environ)) signals.request_started.send(sender=self.__class__) try: response = self.get_response(request) if not response: return finally: signals.request_finished.send(sender=self.__class__) self.set_status(response.status_code) for h in response.items(): self.set_header(h[0], h[1]) if not hasattr(self, "_new_cookies"): self._new_cookies = [] # type: List[http.cookie.SimpleCookie] self._new_cookies.append(response.cookies) self.write(response.content) self.finish()
async def convert_tornado_request_to_django_request(self) -> HttpRequest: # This takes the WSGI environment that Tornado received (which # fully describes the HTTP request that was sent to Tornado) # and pass it to Django's WSGIRequest to generate a Django # HttpRequest object with the original Tornado request's HTTP # headers, parameters, etc. environ = WSGIContainer.environ(self.request) environ["PATH_INFO"] = urllib.parse.unquote(environ["PATH_INFO"]) # Django WSGIRequest setup code that should match logic from # Django's WSGIHandler.__call__ before the call to # `get_response()`. set_script_prefix(get_script_name(environ)) await sync_to_async( lambda: signals.request_started.send(sender=self.__class__), thread_sensitive=True)() self._request = WSGIRequest(environ) # We do the import during runtime to avoid cyclic dependency from zerver.lib.request import RequestNotes # Provide a way for application code to access this handler # given the HttpRequest object. RequestNotes.get_notes( self._request).tornado_handler_id = self.handler_id return self._request
def add_tornado_request_to_notification(self, event: bugsnag.Event): if not hasattr(self, "request"): return event.request = self.request request_tab = { 'method': self.request.method, 'path': self.request.path, 'GET': parse_qs(self.request.query), 'POST': {}, 'url': self.request.full_url(), } # type: Dict[str, Any] try: if (len(self.request.body) > 0): headers = self.request.headers body = self.request.body.decode('utf-8', 'replace') is_json = is_json_content_type(headers.get('Content-Type', '')) if is_json and request_tab["method"] == "POST": request_tab["POST"] = json.loads(body) else: request_tab["POST"] = self.request.body_arguments except Exception: pass event.add_tab("request", request_tab) if bugsnag.configure().send_environment: env = WSGIContainer.environ(self.request) event.add_tab("environment", env)
def get(self): # based on wsgi.WSGIContainer # TODO: handle iterator response data = {} response = [] def start_response(status, response_headers, exc_info=None): data["status"] = status data["headers"] = response_headers return response.append app_response = yield self.executor.submit( self.wsgi_application, WSGIContainer.environ(self.request), start_response) response.extend(app_response) body = b"".join(response) if hasattr(app_response, "close"): yield self.executor.submit(app_response.close) if not data: raise Exception("WSGI app did not call start_response") status_code, reason = data["status"].split(None, 1) status_code = int(status_code) headers = data["headers"] body = escape.utf8(body) self.set_status(status_code, reason) for key, value in headers: self.set_header(key, value) self.write(body)
def get_django_request(self): request = \ WSGIRequest(WSGIContainer.environ(self.request)) request.session = self.get_django_session() if self.current_user: request.user = self.current_user else: request.user = auth.models.AnonymousUser() return request
def __call__(self, request): data = {} response = [] def start_response(status, response_headers, exc_info=None): data["status"] = status data["headers"] = response_headers return response.append app_response = self.wsgi_app( WSGIContainer.environ(request), start_response) try: response.extend(app_response) body = b"".join(response) finally: if hasattr(app_response, "close"): app_response.close() if not data: raise Exception("WSGI app did not call start_response") status_code, reason = data["status"].split(' ', 1) status_code = int(status_code) headers = data["headers"] header_set = set(k.lower() for (k, v) in headers) body = escape.utf8(body) if HEAD_END in body: body = body.replace(HEAD_END, self.script + HEAD_END) if status_code != 304: if "content-type" not in header_set: headers.append(( "Content-Type", "application/octet-stream; charset=UTF-8" )) if "content-length" not in header_set: headers.append(("Content-Length", str(len(body)))) if "server" not in header_set: headers.append(("Server", "LiveServer")) start_line = httputil.ResponseStartLine( "HTTP/1.1", status_code, reason ) header_obj = httputil.HTTPHeaders() for key, value in headers: if key.lower() == 'content-length': value = str(len(body)) header_obj.add(key, value) request.connection.write_headers(start_line, header_obj, chunk=body) request.connection.finish() self._log(status_code, request)
def get(self): from tornado.wsgi import HTTPRequest, WSGIContainer from django.core.handlers.wsgi import WSGIRequest, STATUS_CODE_TEXT import urllib environ = WSGIContainer.environ(self.request) environ["PATH_INFO"] = urllib.unquote(environ["PATH_INFO"]) request = WSGIRequest(environ) request._tornado_handler = self set_script_prefix(base.get_script_name(environ)) signals.request_started.send(sender=self.__class__) try: response = self.get_response(request) if not response: return # Apply response middleware for middleware_method in self._response_middleware: response = middleware_method(request, response) response = self.apply_response_fixes(request, response) finally: signals.request_finished.send(sender=self.__class__) try: status_text = STATUS_CODE_TEXT[response.status_code] except KeyError: status_text = "UNKNOWN STATUS CODE" status = "%s %s" % (response.status_code, status_text) self.set_status(response.status_code) for h in response.items(): self.set_header(h[0], h[1]) """ if not hasattr(self, "_new_cookies"): self._new_cookies = [] self._new_cookies.append(response.cookies) """ # Tornado 2.3 has changed the _new_cookies methods. Its not an array. # revert back to old method for c in response.cookies.values(): self.set_header("Set-Cookie", str(c.output(header=""))) self.write(response.content) self.finish()
def __call__(self, request): data = {} response = [] def start_response(status, response_headers, exc_info=None): data["status"] = status data["headers"] = response_headers return response.append app_response = self.wsgi_application( WSGIContainer.environ(request), start_response) try: response.extend(app_response) body = b"".join(response) finally: if hasattr(app_response, "close"): app_response.close() if not data: raise Exception("WSGI app did not call start_response") status_code = int(data["status"].split()[0]) headers = data["headers"] header_set = set(k.lower() for (k, v) in headers) body = escape.utf8(body) body = body.replace( b'</head>', b'<script src="/livereload.js"></script></head>' ) if status_code != 304: if "content-length" not in header_set: headers.append(("Content-Length", str(len(body)))) if "content-type" not in header_set: headers.append(("Content-Type", "text/html; charset=UTF-8")) if "server" not in header_set: headers.append(("Server", "livereload-tornado")) parts = [escape.utf8("HTTP/1.1 " + data["status"] + "\r\n")] for key, value in headers: if key.lower() == 'content-length': value = str(len(body)) parts.append( escape.utf8(key) + b": " + escape.utf8(value) + b"\r\n" ) parts.append(b"\r\n") parts.append(body) request.write(b"".join(parts)) request.finish() self._log(status_code, request)
def get(self) : from tornado.wsgi import HTTPRequest, WSGIContainer from django.core.handlers.wsgi import WSGIRequest, STATUS_CODE_TEXT import urllib environ = WSGIContainer.environ(self.request) environ['PATH_INFO'] = urllib.unquote(environ['PATH_INFO']) request = WSGIRequest(environ) request._tornado_handler = self set_script_prefix(base.get_script_name(environ)) signals.request_started.send(sender=self.__class__) try: response = self.get_response(request) if not response : return # Apply response middleware for middleware_method in self._response_middleware: response = middleware_method(request, response) response = self.apply_response_fixes(request, response) finally: signals.request_finished.send(sender=self.__class__) try: status_text = STATUS_CODE_TEXT[response.status_code] except KeyError: status_text = 'UNKNOWN STATUS CODE' status = '%s %s' % (response.status_code, status_text) self.set_status(response.status_code) for h in response.items() : self.set_header(h[0], h[1]) for c in response.cookies.values(): self.set_header('Set-Cookie', str(c.output(header=''))) """ if hasattr(self, "_new_cookies"): print self._new_cookies self._new_cookies = response.cookies """ self.write(response.content) self.finish()
def __call__(self, request): parts = [] parts_append = parts.append base_header = strftime('\r\nDate: %a, %d %b %Y %H:%M:%S GMT', gmtime()) + '\r\nServer: tornado\r\n' if not request.supports_http_1_1(): if request.headers.get('Connection', '').lower() == 'keep-alive': base_header += 'Connection: Keep-Alive\r\n' def start_response(status, response_headers, exc_info=None): parts_append(utf8('HTTP/1.1 ' + status + base_header)) for key, value in response_headers: parts_append(utf8(key + ': ' + value + '\r\n')) parts_append(self.new_line) return None environ = WSGIContainer.environ(request) environ['wsgi.multiprocess'] = False # Some EvalException middleware fails if set to True app_response = self.wsgi_application(environ, start_response) if not parts: raise Exception('WSGI app did not call start_response') if request.method != 'HEAD': parts.extend(app_response) if hasattr(app_response, 'close'): app_response.close() app_response = None if hasattr(request, "connection"): # Now that the request is finished, clear the callback we # set on the IOStream (which would otherwise prevent the # garbage collection of the RequestHandler when there # are keepalive connections) request.connection.stream.set_close_callback(None) request.write(self.empty_string.join(parts)) try: request.finish() except IOError as e: self.logger.error('Exception when writing response: %s', str(e))
def get(self) : from tornado.wsgi import HTTPRequest, WSGIContainer from django.core.handlers.wsgi import WSGIRequest, STATUS_CODE_TEXT import urllib environ = WSGIContainer.environ(self.request) environ['PATH_INFO'] = urllib.unquote(environ['PATH_INFO']) request = WSGIRequest(environ) request._tornado_handler = self set_script_prefix(base.get_script_name(environ)) signals.request_started.send(sender=self.__class__) try: response = self.get_response(request) if not response : return # Apply response middleware for middleware_method in self._response_middleware: response = middleware_method(request, response) response = self.apply_response_fixes(request, response) finally: signals.request_finished.send(sender=self.__class__) try: status_text = STATUS_CODE_TEXT[response.status_code] except KeyError: status_text = 'UNKNOWN STATUS CODE' status = '%s %s' % (response.status_code, status_text) self.set_status(response.status_code) for h in response.items() : self.set_header(h[0], h[1]) if not hasattr(self, "_new_cookies"): self._new_cookies = [] self._new_cookies.append(response.cookies) self.write(response.content) self.finish()
def convert_tornado_request_to_django_request(self) -> HttpRequest: # This takes the WSGI environment that Tornado received (which # fully describes the HTTP request that was sent to Tornado) # and pass it to Django's WSGIRequest to generate a Django # HttpRequest object with the original Tornado request's HTTP # headers, parameters, etc. environ = WSGIContainer.environ(self.request) environ['PATH_INFO'] = urllib.parse.unquote(environ['PATH_INFO']) # Django WSGIRequest setup code that should match logic from # Django's WSGIHandler.__call__ before the call to # `get_response()`. set_script_prefix(get_script_name(environ)) signals.request_started.send(sender=self.__class__) request = WSGIRequest(environ) # Provide a way for application code to access this handler # given the HttpRequest object. request._tornado_handler = self return request
def __init__(self, *args, **kwargs): _RequestHandler.__init__(self, *args, **kwargs) self.environ = WSGIContainer.environ(self.request)
def __call__(self, request): data = {} response = [] def start_response(status, response_headers, exc_info=None): data["status"] = status data["headers"] = response_headers return response.append app_response = self.wsgi_application(WSGIContainer.environ(request), start_response) try: response.extend(app_response) body = b"".join(response) finally: if hasattr(app_response, "close"): app_response.close() if not data: raise Exception("WSGI app did not call start_response") status_code = int(data["status"].split()[0]) headers = data["headers"] header_set = set(k.lower() for (k, v) in headers) body = escape.utf8(body) if status_code != 304: if "content-length" not in header_set: headers.append(("Content-Length", str(len(body)))) if "content-type" not in header_set: headers.append(("Content-Type", "text/html; charset=UTF-8")) if "server" not in header_set: headers.append(("Server", "TornadoServer/%s" % tornado.version)) # try: # if request.method.lower() != GET: # _cookies = Cookie.SimpleCookie() # Django session cookies are set at the django level, but # tornado-specific cookies are appended here. # token = request.cookies[djsettings.CSRF_COOKIE_NAME] # if token: # _cookies[settings.XSRF_TOKEN] = token.value # TODO Change when we add more contexts # _cookies[settings.CONTEXT_COOKIE] = settings.DEFAULT_CONTEXT # for c in _cookies.output(sep='\t').split('\t'): # k, v = c.split(': ') # headers.append((k, v + '; Path=/')) # except ValueError as e: # logging.getLogger("ef5").error("A Value is either missing or invalid: {0}".format(e)) # except Exception as e: # logging.getLogger("ef5").error("An unknown error occurred: {0} with stacktrace {1}".format(e, traceback.format_exc())) parts = [escape.utf8("HTTP/1.1 " + data["status"] + "\r\n")] for key, value in headers: parts.append(escape.utf8(key) + b": " + escape.utf8(value) + b"\r\n") parts.append(b"\r\n") parts.append(body) request.write(b"".join(parts)) request.finish() self._log(status_code, request)
def environ(request: httputil.HTTPServerRequest) -> Dict[Text, Any]: environ = WSGIContainer.environ(request) environ['RAW_URI'] = request.path return environ
def __init__(self, tornado_request_type, cookies=None): self._tornado_request = tornado_request_type self._cookies = cookies environ = WSGIContainer.environ(tornado_request_type) super(DjangoRequest,self).__init__(environ) self.tornado_to_django()
def wrapper(request, response): req = yield request.read() datas = yield application(WSGIContainer.environ(req), partial(start_response, response)) for data in datas: response.write(data) response.close()
def wrapper(request, response): req = yield request.read() for data in application(WSGIContainer.environ(req), functools.partial(start_response, response)): response.write(data) response.close()
def use_scope() -> dict[str, Any]: """Get the current WSGI environment dictionary""" return WSGIContainer.environ(use_request())