def __call__(self, environ, start_response): if self.urlmap is None: raise NotImplementedError('Please provide urlmap') urls = self.urlmap.bind_to_environ(environ) self.logger.debug(self.__class__.__name__ + ': handling request') res = None try: endpoint, kwargs = urls.match() res = getattr(self, 'subapp_' + endpoint, None) if res is not None: utils.pop_path(environ) return res(environ, start_response) res = getattr(self, 'app_' + endpoint, None) if res is not None: return res(environ, start_response) attr = getattr(self, 'respond_' + endpoint, None) if attr is not None: res = attr(werkzeug.Request(environ), **kwargs) return res(environ, start_response) except werkexc.NotFound, exc: tmpl = self.templates.get_template('404.html') req = werkzeug.Request(environ) res = werkzeug.Response(tmpl.render(exc=exc, url_root=req.url_root, version=__version__), content_type='text/html; charset=UTF-8', status=404) return res(environ, start_response)
def test_create_render(): templates = { u'index': u"This is the index page. Path: {{ request.path }}. Greeting: {{ greeting }}", u'about': u"This is the about page. Path: {{ request.path }}" } env = j2.Environment(loader=j2.DictLoader(templates)) render = wu.create_render(env) @render(u"index") def index_page(req): return {u'greeting': "Hello"} @render(u"about") def about_page(req): return {} @render(u"contact") def contact(req): return wz.redirect(u"/other_page") req = wz.Request(utils.MockEnv(u"/", u"GET")) res = index_page(req) assert res.response[ 0] == "This is the index page. Path: /. Greeting: Hello" res = about_page(req) assert res.response[0] == "This is the about page. Path: /" res = contact(req) assert u"Redirecting..." in res.response[0] assert u"/other_page" in res.response[0]
def __call__(self, environ, start_response): if not self.baseurl: return self.app(environ, start_response) req = werkzeug.Request(environ) script_name = new_script_name = environ.get('SCRIPT_NAME', '') http_host = new_http_host = environ.get('HTTP_HOST', '') if self.baseurl.startswith('/'): new_script_name = self.baseurl else: parts = self.baseurl.split('/') new_script_name = '/'.join(parts[3:]) + script_name new_http_host = parts[2] if not new_script_name.startswith('/'): new_script_name = '/' + new_script_name if not new_script_name.endswith('/'): new_script_name += '/' environ['SCRIPT_NAME'] = new_script_name environ['HTTP_HOST'] = environ['SERVER_NAME'] = new_http_host self.logger.debug('Fixed script_name to be: %s' % new_script_name) self.logger.debug('Fixing host to be: %s' % new_http_host) return self.app(environ, start_response)
def __call__(self, environ, start_response): try: request = werkzeug.Request(environ) adapter = self._url_map.bind_to_environ(environ) endpoint, values = adapter.match() # Dispatch request response = endpoint(request, **values) response = _json_response(response) except werkzeug.exceptions.HTTPException as e: response = _json_response( { "code": e.code, "name": e.name, "description": e.description }, status=e.code, ) except Exception as e: response = _json_response( { "code": 500, "name": "Internal Server Error" }, status=500) print(f"ERROR {e.__class__.__name__}: {str(e)}", file=sys.stderr) traceback.print_exc(file=sys.stderr) return response(environ, start_response)
def globs(self, environ, **extra): req = werkzeug.Request(environ) all = {'url_root': req.url_root} if environ.get('REMOTE_USER', False): all['remote_user'] = environ['REMOTE_USER'] all.update(extra) return all
def application(environ, start_response): _request = werkzeug.Request(environ) _data = json.loads(_request.get_data().decode("utf-8")) to_json = {"result": super_additionneur(_data["param1"], _data["param2"])} return werkzeug.Response(json.dumps(to_json), mimetype='application/json')(environ, start_response)
def application(environ, start_response): request = werkzeug.Request(environ) response = werkzeug.Response() if request.method != "GET": response.status = 405 else: fetch_content(request, response) return response(environ, start_response)
def render_best_content_type(environ, title, content): """Return a response rendered using talisker.render.""" request = werkzeug.Request(environ) content_type = request.accept_mimetypes.best_match( ['text/plain', 'text/html', 'application/json'], default='text/plain', ) return ( content_type, render_type(content_type, Head(title), content), )
def __call__(self, environ, start_response): routes = self.routes.bind_to_environ(environ) request = werkzeug.Request(environ) try: endpoint, arguments = routes.match() response = endpoint(request) except werkzeug.exceptions.HTTPException as e: response = e except Exception as e: response = werkzeug.exceptions.InternalServerError(str(e)) return response(environ, start_response)
def traced_wsgi_app(pin, wrapped, instance, args, kwargs): """ Wrapper for flask.app.Flask.wsgi_app This wrapper is the starting point for all requests. """ # DEV: This is safe before this is the args for a WSGI handler # https://www.python.org/dev/peps/pep-3333/ environ, start_response = args # Create a werkzeug request from the `environ` to make interacting with it easier # DEV: This executes before a request context is created request = werkzeug.Request(environ) # Configure distributed tracing trace_utils.activate_distributed_headers(pin.tracer, int_config=config.flask, request_headers=request.headers) # Default resource is method and path: # GET / # POST /save # We will override this below in `traced_dispatch_request` when we have a `RequestContext` and possibly a url rule resource = u" ".join((request.method, request.path)) with pin.tracer.trace( "flask.request", service=trace_utils.int_service(pin, config.flask), resource=resource, span_type=SpanTypes.WEB, ) as span: span.set_tag(SPAN_MEASURED_KEY) # set analytics sample rate with global config enabled sample_rate = config.flask.get_analytics_sample_rate( use_global_config=True) if sample_rate is not None: span.set_tag(ANALYTICS_SAMPLE_RATE_KEY, sample_rate) span._set_str_tag(FLASK_VERSION, flask_version_str) start_response = _wrap_start_response(start_response, span, request) # DEV: We set response status code in `_wrap_start_response` # DEV: Use `request.base_url` and not `request.url` to keep from leaking any query string parameters trace_utils.set_http_meta( span, config.flask, method=request.method, url=request.base_url, query=request.query_string, request_headers=request.headers, ) return wrapped(environ, start_response)
def __call__(self, environ, start_response): with self.loghandler.threadbound(): request = werkzeug.Request(environ) m = self.mapper.match(environ=environ) if m is not None: handler = m['handler'](app=self, request=request, settings=self.settings) try: return handler.handle(**m)(environ, start_response) except werkzeug.exceptions.HTTPException, e: return e(environ, start_response) # no view found => 404 return werkzeug.exceptions.NotFound()(environ, start_response)
def application(environ, start_response): """ """ global mapfile #global kwargs global MAP_CACHE req = z.Request(environ) if req.method == 'POST' and not req.data == 'Paste mapfile here': #import pdb;pdb.set_trace() xml_string = req.data mapfile = '/tmp/mapfile%s.xml' % random.random() tmp = open(mapfile, 'w+b') tmp.write(xml_string) tmp.seek(0) tmp.close() MAP_CACHE.mapfile = mapfile MAP_CACHE.load_map() if req.path in views: resp = views[req.path](req) elif req.path == '/tiles': # Used cached map and projection if instance exists if not MAP_CACHE: MAP_CACHE = MapResponse(req.values, mapfile) resp = MAP_CACHE(req.values) elif req.path.rstrip('/').endswith('/js'): arg = req.args.get('f') resp = get_resource(req, arg) elif req.path.startswith('/images'): #import pdb;pdb.set_trace() resp = get_resource(req, req.path.lstrip('/')) else: resp = not_found(req) return resp(environ, start_response)
def __call__(self, environ, start_response): request_line = (environ["REQUEST_METHOD"], environ["PATH_INFO"]) if any(request_line == (method, path) for method, path, *_ in self.exempt): # Requests exempted from auth checking are forwarded directly response = self.app else: # All others: Check authorization and then forward to app request = werkzeug.Request(environ) try: user = self._check_authorization(request) environ["REMOTE_USER"] = user response = self.app except Unauthorized as e: response = _json_response( { "code": e.code, "name": e.name, "description": e.description }, status=e.code, ) return response(environ, start_response)
def wsgi_app(self, environ: Dict[str, Any], start_response: Callable): environ['app'] = self request = werkzeug.Request(environ) response = self._rpc_handle(request) return response(environ, start_response)
def WsgiApplication(environ, start_response): appServer.LastRequestTime = time.time() appServer.Local.Request = request = werkzeug.Request(environ) response = appServer.ProcessRequest(request) return response(environ, start_response)
def from_environment(cls, environment): with werkzeug.Request(environment, populate_request=False) as request: return cls(request)
def traced_wsgi_app(pin, wrapped, instance, args, kwargs): """ Wrapper for flask.app.Flask.wsgi_app This wrapper is the starting point for all requests. """ # DEV: This is safe before this is the args for a WSGI handler # https://www.python.org/dev/peps/pep-3333/ environ, start_response = args # Create a werkzeug request from the `environ` to make interacting with it easier # DEV: This executes before a request context is created request = werkzeug.Request(environ) # Configure distributed tracing trace_utils.activate_distributed_headers(pin.tracer, int_config=config.flask, request_headers=request.headers) # Default resource is method and path: # GET / # POST /save # We will override this below in `traced_dispatch_request` when we have a `RequestContext` and possibly a url rule resource = u"{} {}".format(request.method, request.path) with pin.tracer.trace( "flask.request", service=trace_utils.int_service(pin, config.flask), resource=resource, span_type=SpanTypes.WEB, ) as s: s.set_tag(SPAN_MEASURED_KEY) # set analytics sample rate with global config enabled sample_rate = config.flask.get_analytics_sample_rate( use_global_config=True) if sample_rate is not None: s.set_tag(ANALYTICS_SAMPLE_RATE_KEY, sample_rate) s.set_tag(FLASK_VERSION, flask_version_str) # Wrap the `start_response` handler to extract response code # DEV: We tried using `Flask.finalize_request`, which seemed to work, but gave us hell during tests # DEV: The downside to using `start_response` is we do not have a `Flask.Response` object here, # only `status_code`, and `headers` to work with # On the bright side, this works in all versions of Flask (or any WSGI app actually) def _wrap_start_response(func): def traced_start_response(status_code, headers): code, _, _ = status_code.partition(" ") try: code = int(code) except ValueError: pass # Override root span resource name to be `<method> 404` for 404 requests # DEV: We do this because we want to make it easier to see all unknown requests together # Also, we do this to reduce the cardinality on unknown urls # DEV: If we have an endpoint or url rule tag, then we don't need to do this, # we still want `GET /product/<int:product_id>` grouped together, # even if it is a 404 if not s.get_tag(FLASK_ENDPOINT) and not s.get_tag( FLASK_URL_RULE): s.resource = u"{} {}".format(request.method, code) trace_utils.set_http_meta(s, config.flask, status_code=code, response_headers=headers) return func(status_code, headers) return traced_start_response start_response = _wrap_start_response(start_response) # DEV: We set response status code in `_wrap_start_response` # DEV: Use `request.base_url` and not `request.url` to keep from leaking any query string parameters trace_utils.set_http_meta( s, config.flask, method=request.method, url=request.base_url, query=request.query_string, request_headers=request.headers, ) return wrapped(environ, start_response)
res = attr(werkzeug.Request(environ), **kwargs) return res(environ, start_response) except werkexc.NotFound, exc: tmpl = self.templates.get_template('404.html') req = werkzeug.Request(environ) res = werkzeug.Response(tmpl.render(exc=exc, url_root=req.url_root, version=__version__), content_type='text/html; charset=UTF-8', status=404) return res(environ, start_response) except werkexc.HTTPException, exc: return exc(environ, start_response) res = werkzeug.Response(werkzeug.Request(environ).path, status=404) return res(environ, start_response) def globs(self, environ, **extra): req = werkzeug.Request(environ) all = {'url_root': req.url_root} if environ.get('REMOTE_USER', False): all['remote_user'] = environ['REMOTE_USER'] all.update(extra) return all class SimpleIndexApp(AbstractPyPiApp): """Represents one index in the pypi server.
def traced_wsgi_app(pin, wrapped, instance, args, kwargs): """ Wrapper for flask.app.Flask.wsgi_app This wrapper is the starting point for all requests. """ # DEV: This is safe before this is the args for a WSGI handler # https://www.python.org/dev/peps/pep-3333/ environ, start_response = args # Create a werkzeug request from the `environ` to make interacting with it easier # DEV: This executes before a request context is created request = werkzeug.Request(environ) # Configure distributed tracing if config.flask.get('distributed_tracing_enabled', False): propagator = HTTPPropagator() context = propagator.extract(request.headers) # Only need to activate the new context if something was propagated if context.trace_id: pin.tracer.context_provider.activate(context) # Default resource is method and path: # GET / # POST /save # We will override this below in `traced_dispatch_request` when we have a `RequestContext` and possibly a url rule resource = u'{} {}'.format(request.method, request.path) with pin.tracer.trace('flask.request', service=pin.service, resource=resource, span_type=http.TYPE) as s: # set analytics sample rate with global config enabled sample_rate = config.flask.get_analytics_sample_rate( use_global_config=True) if sample_rate is not None: s.set_tag(ANALYTICS_SAMPLE_RATE_KEY, sample_rate) s.set_tag(FLASK_VERSION, flask_version_str) # Wrap the `start_response` handler to extract response code # DEV: We tried using `Flask.finalize_request`, which seemed to work, but gave us hell during tests # DEV: The downside to using `start_response` is we do not have a `Flask.Response` object here, # only `status_code`, and `headers` to work with # On the bright side, this works in all versions of Flask (or any WSGI app actually) def _wrap_start_response(func): def traced_start_response(status_code, headers): code, _, _ = status_code.partition(' ') try: code = int(code) except ValueError: pass # Override root span resource name to be `<method> 404` for 404 requests # DEV: We do this because we want to make it easier to see all unknown requests together # Also, we do this to reduce the cardinality on unknown urls # DEV: If we have an endpoint or url rule tag, then we don't need to do this, # we still want `GET /product/<int:product_id>` grouped together, # even if it is a 404 if not s.get_tag(FLASK_ENDPOINT) and not s.get_tag( FLASK_URL_RULE): s.resource = u'{} {}'.format(request.method, code) s.set_tag(http.STATUS_CODE, code) if 500 <= code < 600: s.error = 1 elif code in config.flask.get('extra_error_codes', set()): s.error = 1 return func(status_code, headers) return traced_start_response start_response = _wrap_start_response(start_response) # DEV: We set response status code in `_wrap_start_response` # DEV: Use `request.base_url` and not `request.url` to keep from leaking any query string parameters s.set_tag(http.URL, request.base_url) s.set_tag(http.METHOD, request.method) if config.flask.trace_query_string: s.set_tag(http.QUERY_STRING, compat.to_unicode(request.query_string)) return wrapped(environ, start_response)