def db(path): #raise Exception(session['user_id']) headers = {'Content-type':'text/html', 'Cache-Control':'no-cache, no-store, max-age=0, must-revalidate'} if g.user: pop_path_info(request.environ) status = '200 OK' environ = request.environ method = environ.get('REQUEST_METHOD') path = environ.get('PATH_INFO') query = environ.get('QUERY_STRING') body= '' # b'' for consistency on Python 3.0 couch = get_couch() try: length= int(environ.get('CONTENT_LENGTH', '0')) except ValueError: length = 0 if length != 0: body = environ['wsgi.input'].read(length) status,response = couch.process(method,path,query,session['user_id'],body) else: response = 'need log in to procee operation' status = '200 OK' return make_response(response,status,headers)
def db(path): #raise Exception(session['user_id']) headers = { 'Content-type': 'text/html', 'Cache-Control': 'no-cache, no-store, max-age=0, must-revalidate' } if g.user: pop_path_info(request.environ) status = '200 OK' environ = request.environ method = environ.get('REQUEST_METHOD') path = environ.get('PATH_INFO') query = environ.get('QUERY_STRING') body = '' # b'' for consistency on Python 3.0 couch = get_couch() try: length = int(environ.get('CONTENT_LENGTH', '0')) except ValueError: length = 0 if length != 0: body = environ['wsgi.input'].read(length) status, response = couch.process(method, path, query, session['user_id'], body) else: response = 'need log in to procee operation' status = '200 OK' return make_response(response, status, headers)
def __call__(self, environ, start_response): app = self.get_application(peek_path_info(environ)) if app is not None: pop_path_info(environ) else: app = self.default_app return app(environ, start_response)
def setup_paths(self, environ, coll, record=False): """Populates the WSGI environment dictionary with the path information necessary to perform a response for content or record. :param dict environ: The WSGI environment dictionary for the request :param str coll: The name of the collection the record is to be served from :param bool record: Should the content being served by recorded (save to a warc). Only valid in record mode """ if not coll or not self.warcserver.root_dir: return if coll != '$root': pop_path_info(environ) if record: pop_path_info(environ) paths = [self.warcserver.root_dir] if coll != '$root': paths.append(coll) paths.append(self.templates_dir) # jinja2 template paths always use '/' as separator environ['pywb.templates_dir'] = '/'.join(paths)
def handle(self, request): """Handle a request, parse and validate arguments and dispatch the request.""" entity = pop_path_info(request.environ) if request.method == "OPTIONS": return self.handle_options(request, entity) if not entity: return self.handle_index() elif entity == "robots.txt": return self.handle_robots() elif entity == "main.css": return self.handle_css() elif entity == "img": return self.handle_svg_img(pop_path_info(request.environ)) elif entity == "js": return self.handle_js(pop_path_info(request.environ)) elif entity == 'api': return self.handle_api(request) self.validate_entity(entity) req_mbid = shift_path_info(request.environ) self.validate_mbid(req_mbid) mbid = self.resolve_mbid(entity, req_mbid) filename = pop_path_info(request.environ) if entity == 'release-group': return self.handle_release_group(request, mbid, filename) else: return self.handle_release(request, mbid, filename)
def handle(self, request): '''Handle a request, parse and validate arguments and dispatch the request''' entity = pop_path_info(request.environ) if not entity: return self.handle_index() if entity not in [ 'release', 'release-group' ]: return Response ( status=400, response= "Only release and release-group entities are currently supported") req_mbid = shift_path_info(request.environ) if not req_mbid: return Response (status=400, response="no MBID specified.") if not re.match('[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$', req_mbid): return Response (status=400, response="invalid MBID specified.") mbid = self.resolve_mbid (entity, req_mbid) filename = pop_path_info(request.environ) if entity == 'release-group': return self.handle_release_group (request, mbid, filename) else: return self.handle_release (request, mbid, filename)
def handle(self, request): """Handle a request, parse and validate arguments and dispatch the request.""" entity = pop_path_info(request.environ) if request.method == "OPTIONS": return self.handle_options(request, entity) if not entity: return self.handle_index() elif entity == "robots.txt": return self.handle_robots() elif entity == "main.css": return self.handle_css() elif entity == "img": return self.handle_svg_img(pop_path_info(request.environ)) elif entity == "js": return self.handle_js(pop_path_info(request.environ)) elif entity == "api": return self.handle_api(request) self.validate_entity(entity) req_mbid = shift_path_info(request.environ) self.validate_mbid(req_mbid) mbid = self.resolve_mbid(entity, req_mbid) filename = pop_path_info(request.environ) if entity == "release-group": return self.handle_release_group(request, mbid, filename) else: return self.handle_release(request, mbid, filename)
def __call__(self, environ, start_response): prefix = wsgi.peek_path_info(environ) if prefix != "local": return self.default_app(environ, start_response) _ = wsgi.pop_path_info(environ) cid = wsgi.pop_path_info(environ) store_app = _local_store_app(cid) return store_app(environ, start_response)
def __call__(self, environ, start_response): my_app = self.instances.get(peek_path_info(environ)) if my_app is not None: pop_path_info(environ) else: my_app = self.default_app return my_app(environ, start_response)
def __call__(self, environ, start_response): from werkzeug.wsgi import pop_path_info, get_path_info app = self.get_application(get_path_info(environ)) if app is not None: for i in range(app.peeks): pop_path_info(environ) app = app.app # print get_path_info(environ), app else: # use default app app = self.default_app return app(environ, start_response)
def __call__(self, environ, start_response): from werkzeug.wsgi import pop_path_info, get_path_info app = self.get_application(get_path_info(environ)) if app is not None: for i in range(app.peeks): pop_path_info(environ) app = app.app #print get_path_info(environ), app else: #use default app app = self.default_app return app(environ, start_response)
def __call__(self, environ, start_response): request = Request(environ, shallow=True) # Dispatch to the web admin if we need. if request.path.rstrip('/').startswith('/admin'): pop_path_info(environ) return self.admin(environ, start_response) try: response = self.handle_request(request) except HTTPException as e: response = e return response(environ, start_response)
def handle_request(self, environ, start_response): """Retrieves the route handler and calls the handler returning its the response :param dict environ: The WSGI environment dictionary for the request :param start_response: :return: The WbResponse for the request :rtype: WbResponse """ urls = self.url_map.bind_to_environ(environ) try: endpoint, args = urls.match() self.rewriterapp.prepare_env(environ) # store original script_name (original prefix) before modifications are made environ['ORIG_SCRIPT_NAME'] = environ.get('SCRIPT_NAME') lang = args.pop('lang', '') if lang: pop_path_info(environ) environ['pywb_lang'] = lang response = endpoint(environ, **args) except RequestRedirect as rr: # if werkzeug throws this, likely a missing slash redirect # also check referrer here to avoid another redirect later redir = self._check_refer_redirect(environ) if redir: return redir(environ, start_response) response = WbResponse.redir_response(rr.new_url, '307 Redirect') except WbException as wbe: if wbe.status_code == 404: redir = self._check_refer_redirect(environ) if redir: return redir(environ, start_response) response = self.rewriterapp.handle_error(environ, wbe) except Exception as e: if self.debug: traceback.print_exc() response = self.rewriterapp._error_response( environ, WbException('Internal Error: ' + str(e))) return response(environ, start_response)
def authenticated(self, wrapped, instance, args, kwargs): environ, start_response = args requested_mailbox = pop_path_info(environ) auth_data = environ.get("HTTP_AUTHORIZATION", "") if not auth_data: return NotAuthorized(environ, start_response) if auth_data.startswith("NHSMESH "): auth_data = auth_data[8:] mailbox, nonce, nonce_count, ts, hashed = auth_data.split(":") expected_password = self._client_password hash_data = ":".join( [mailbox, nonce, nonce_count, expected_password, ts]) myhash = hmac.HMAC(self._shared_key, hash_data.encode("ascii"), sha256).hexdigest() with self.db_env.begin(self.nonce_db, write=True) as auth_tx: nonce_key = ':'.join([mailbox, nonce]).encode('ascii') current_nonce_count = auth_tx.get(nonce_key, b'-1').decode('ascii') nonce_used = int(nonce_count) <= int(current_nonce_count) auth_tx.put(nonce_key, nonce_count.encode('ascii')) if myhash == hashed and mailbox == requested_mailbox and not nonce_used: environ["mesh.mailbox"] = mailbox return wrapped(environ, start_response) else: return Forbidden(environ, start_response)
def inner(environ, start_response): client_name = pop_path_info(environ) if not client_name: return NotFound()(environ, start_response) environ['REMOTE_USER'] = client_name return app(environ, start_response)
def setup_paths(self, environ, coll, record=False): if not coll or not self.warcserver.root_dir: return if coll != '$root': pop_path_info(environ) if record: pop_path_info(environ) paths = [self.warcserver.root_dir] if coll != '$root': paths.append(coll) paths.append(self.templates_dir) # jinja2 template paths always use '/' as separator environ['pywb.templates_dir'] = '/'.join(paths)
def __call__(self, environ, start_response): path_prefix = peek_path_info(environ) self._log.debug("Base application __call__ path prefix: '%s'", path_prefix) if path_prefix and path_prefix not in self.PREFIX_BLACKLIST: app = self.get_application(path_prefix) if app is not None: pop_path_info(environ) else: self._log.debug("No IQR application registered for prefix: " "'%s'", path_prefix) app = NotFound() else: self._log.debug("No prefix or prefix in blacklist. " "Using dispatcher app.") app = self.wsgi_app return app(environ, start_response)
def outbox(self, environ, start_response): message_id = pop_path_info(environ) if message_id == 'tracking': return self.tracking(environ, start_response) elif message_id: return self.handle_chunk_upload(message_id, environ, start_response) else: return self.handle_first_chunk(environ, start_response)
def handle_chunk_upload(self, message_id, environ, start_response): chunk_num = pop_path_info(environ) with self.db_env.begin(db=self.metadata_db) as tx: metadata = pickle.loads(tx.get(message_id.encode('ascii'))) self.save_chunk(environ, metadata.recipient, message_id, chunk_num) if int(chunk_num) == metadata.chunks: metadata = metadata._replace(all_chunks_received=True) with self.db_env.begin(db=self.metadata_db, write=True) as tx: tx.put(message_id.encode('ascii'), pickle.dumps(metadata)) return Response('', status=202)
def endpoint_lookup(self, environ, start_response): org_code = pop_path_info(environ) workflow_id = pop_path_info(environ) if not org_code or not workflow_id: return NotFound result = { "query_id": "{ts:%Y%m%d%H%M%S%f}_{rnd:06x}_{ts:%s}".format( ts=datetime.datetime.now(), rnd=random.randint(0, 0xffffff)), "results": [{ "address": "{}HC001".format(org_code), "description": "{} {} endpoint".format(org_code, workflow_id), "endpoint_type": "MESH" }] } return Response(json.dumps(result), content_type='application/json')
def __call__(self, environ, start_response): if wsgi.get_path_info(environ).startswith('/users'): # Not nice solution but it works well for now # Return any app, as all apps can handle login return self.call(self.one_app, environ, start_response) inventory = wsgi.pop_path_info(environ) with self.lock: if inventory not in self.instances: self.instantiate() app = self.instances.get(inventory, self.NOT_FOUND) return self.call(app, environ, start_response)
def inbox(self, environ, start_response): request_method = environ["REQUEST_METHOD"] message_id = pop_path_info(environ) mailbox = environ["mesh.mailbox"] if (request_method == "PUT" and environ["PATH_INFO"] == "/status/acknowledged"): self.delete_message(mailbox, message_id) return Response('OK') if request_method == "GET": if message_id: chunk_num = pop_path_info(environ) or 1 return self.download_chunk(mailbox, message_id, chunk_num) else: messages = {"messages": list(self.list_messages(mailbox))} return Response(json.dumps(messages), content_type='application/json') else: return BadRequest
def get_data(environ, start_response): key = pop_path_info(environ) with eliot.start_action(action_type='api:get-data', key=key) as action: data = db.get(key) if data is None: action.add_success_fields(found=False) start_response('404 Not Found', []) return {'error': 'not_found', 'key': key} else: action.add_success_fields(found=True) return data
def __call__(self, environ, start_response): host = environ['HTTP_HOST'] subdomain = self._subdomain(host) path = peek_path_info(environ) if subdomain in self.subdomains: app = self.get_application_by_subdomain(subdomain) else: app = self.get_application_by_path(path) if app is None: app = self.default_instances.get(subdomain) if app is None: app = self.default_app() self.setup_login_manager(app) self.default_instances[subdomain] = app if path in self.strip_paths: pop_path_info(environ) return app(environ, start_response)
def render_chart(environ, start_response): stats = bp_perf.stats chart_name = pop_path_info(environ) if chart_name not in stats: start_response('404 Not Found', [('content-type', 'text/plain; charset=ascii')]) return [b"Chart not found"] else: data = stats[chart_name] chart = pygal.Box(box_mode='tukey', width=1200, height=600) chart.title = chart_name for bp, data in data.items(): chart.add(bp, data) start_response('200 OK', [('content-type', 'image/svg+xml')]) return [chart.render()]
def handle(self, request): '''Handle a request, parse and validate arguments and dispatch the request''' entity = pop_path_info(request.environ) if request.method == "OPTIONS": return self.handle_options(request, entity) if not entity: return self.handle_index() if entity == 'robots.txt': return self.handle_robots() self.validate_entity(entity) req_mbid = shift_path_info(request.environ) self.validate_mbid(req_mbid) mbid = self.resolve_mbid (entity, req_mbid) filename = pop_path_info(request.environ) if entity == 'release-group': return self.handle_release_group (request, mbid, filename) else: return self.handle_release (request, mbid, filename)
def test_pop_path_info(): original_env = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/a/b///c'} # regular path info popping def assert_tuple(script_name, path_info): assert env.get('SCRIPT_NAME') == script_name assert env.get('PATH_INFO') == path_info env = original_env.copy() pop = lambda: wsgi.pop_path_info(env) assert_tuple('/foo', '/a/b///c') assert pop() == 'a' assert_tuple('/foo/a', '/b///c') assert pop() == 'b' assert_tuple('/foo/a/b', '///c') assert pop() == 'c' assert_tuple('/foo/a/b///c', '') assert pop() is None
def test_pop_path_info(self): original_env = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/a/b///c'} # regular path info popping def assert_tuple(script_name, path_info): self.assert_equal(env.get('SCRIPT_NAME'), script_name) self.assert_equal(env.get('PATH_INFO'), path_info) env = original_env.copy() pop = lambda: wsgi.pop_path_info(env) assert_tuple('/foo', '/a/b///c') self.assert_equal(pop(), 'a') assert_tuple('/foo/a', '/b///c') self.assert_equal(pop(), 'b') assert_tuple('/foo/a/b', '///c') self.assert_equal(pop(), 'c') assert_tuple('/foo/a/b///c', '') self.assert_is_none(pop())
def test_pop_path_info(): original_env = {"SCRIPT_NAME": "/foo", "PATH_INFO": "/a/b///c"} # regular path info popping def assert_tuple(script_name, path_info): assert env.get("SCRIPT_NAME") == script_name assert env.get("PATH_INFO") == path_info env = original_env.copy() pop = lambda: wsgi.pop_path_info(env) assert_tuple("/foo", "/a/b///c") assert pop() == "a" assert_tuple("/foo/a", "/b///c") assert pop() == "b" assert_tuple("/foo/a/b", "///c") assert pop() == "c" assert_tuple("/foo/a/b///c", "") assert pop() is None
def test_pop_path_info(self): original_env = {"SCRIPT_NAME": "/foo", "PATH_INFO": "/a/b///c"} # regular path info popping def assert_tuple(script_name, path_info): self.assert_equal(env.get("SCRIPT_NAME"), script_name) self.assert_equal(env.get("PATH_INFO"), path_info) env = original_env.copy() pop = lambda: wsgi.pop_path_info(env) assert_tuple("/foo", "/a/b///c") self.assert_equal(pop(), "a") assert_tuple("/foo/a", "/b///c") self.assert_equal(pop(), "b") assert_tuple("/foo/a/b", "///c") self.assert_equal(pop(), "c") assert_tuple("/foo/a/b///c", "") self.assert_is_none(pop())
def handle_options(self, request, entity): """Repond to OPTIONS requests with a status code of 200 and the allowed request methods. """ if request.environ["SERVER_PROTOCOL"] != "HTTP/1.1": # OPTIONS does not exist in HTTP/1.0 raise NotImplemented() if entity: if not entity == '*': self.validate_entity(entity) elif pop_path_info(request.environ) is not None: # There's more than a single asterisk in the request uri raise BadRequest() else: return Response(status=200, headers=[("Allow", "GET, HEAD, OPTIONS")]) req_mbid = shift_path_info(request.environ) self.validate_mbid(req_mbid) image_id = shift_path_info(request.environ) if image_id and image_id is not None: image_id = splitext(image_id)[0] _split = image_id.split('-') if len(_split) > 0: id_text = _split[0] try: int(id_text) except ValueError: if id_text not in ('front', 'back'): raise BadRequest() else: get_sentry().captureException() if len(_split) > 1: size = _split[1] if size not in ('250', '500'): raise BadRequest() return Response(status=200, headers=[("Allow", "GET, HEAD, OPTIONS")])
def handle_options(self, request, entity): """Repond to OPTIONS requests with a status code of 200 and the allowed request methods. """ if request.environ["SERVER_PROTOCOL"] != "HTTP/1.1": # OPTIONS does not exist in HTTP/1.0 raise NotImplemented() if entity: if not entity == '*': self.validate_entity(entity) elif pop_path_info(request.environ) is not None: # There's more than a single asterisk in the request uri raise BadRequest() else: return Response(status=200, headers=[("Allow", "GET, HEAD, OPTIONS")]) req_mbid = shift_path_info(request.environ) self.validate_mbid(req_mbid) image_id = shift_path_info(request.environ) if image_id and image_id is not None: image_id = splitext(image_id)[0] _split = image_id.split('-') if len(_split) > 0: id_text = _split[0] try: int(id_text) except ValueError: if id_text not in ('front', 'back'): raise BadRequest() else: get_sentry().captureException() if len(_split) > 1: size = _split[1] if size not in ('250', '500', '1200'): raise BadRequest() return Response(status=200, headers=[("Allow", "GET, HEAD, OPTIONS")])
def tracking(self, environ, start_response): local_id = pop_path_info(environ) qs = get_query_string(environ) message_id = parse_qs(qs).get('messageID', [None])[0] if not local_id and not message_id: return BadRequest with self.db_env.begin(db=self.tracking_db) as tx: if local_id: tracking_data = tx.get(local_id.encode('ascii')) else: msg_key = message_id.encode('ascii') tracking_data = tx.get(MSG_TRACKING_PREFIX + msg_key) if not tracking_data: metadata = pickle.loads( tx.get(msg_key, db=self.metadata_db)) tracking_data = json.dumps( make_tracking_data(message_id, metadata)).encode('utf-8') if not tracking_data: return NotFound else: return Response(tracking_data, content_type='application/json')
def _fake_ndr(self, environ, start_response): # POST an empty message to /_fake_ndr/RECIPIENT to add an NDR to recipient's mailbox mailbox_id = pop_path_info(environ) linked_message_id = self._new_message_id() message_id = self._new_message_id() if environ['REQUEST_METHOD'] != 'POST': return BadRequest headers = { 'Mex-Statustimestamp': datetime.datetime.now().strftime(TIMESTAMP_FORMAT), 'Mex-Statussuccess': 'ERROR', 'Mex-Statusdescription': "Unregistered to address", 'Mex-To': mailbox_id, 'Mex-Linkedmsgid': linked_message_id, 'Mex-Messagetype': 'REPORT', 'Mex-Subject': 'NDR', } metadata = Metadata(1, mailbox_id, headers, True) with self.db_env.begin(write=True) as tx: tx.put(message_id.encode('ascii'), pickle.dumps(metadata), db=self.metadata_db) tx.put(mailbox_id.encode('ascii'), message_id.encode('ascii'), dupdata=True, db=self.inbox_db) filename = self.get_filename(mailbox_id, message_id, 1) with open(filename, 'wb') as f: compressor = zlib.compressobj(9, zlib.DEFLATED, 31) f.write(compressor.flush(zlib.Z_FINISH)) return Response(message_id.encode('ascii'))
def __call__(self, environ, start_response): app = self.get_application(peek_path_info(environ)) pop_path_info(environ) return app(environ, start_response)
def pop(): return wsgi.pop_path_info(env)
def middleware(environ, start_response): # modify the environ in place, shouldn't propagate to redirect request pop_path_info(environ) return app(environ, start_response)
def outbox(self, environ, start_response): mailbox_id = environ["mesh.mailbox"] message_id = pop_path_info(environ) if message_id == 'tracking': local_id = pop_path_info(environ) if not local_id: return BadRequest with self.db_env.begin(db=self.tracking_db) as tx: tracking_data = tx.get(local_id.encode('ascii')) if not tracking_data: return NotFound else: return Response(tracking_data, content_type='application/json') elif message_id: chunk_num = pop_path_info(environ) with self.db_env.begin(db=self.metadata_db) as tx: metadata = pickle.loads(tx.get(message_id.encode('ascii'))) self.save_chunk(environ, metadata.recipient, message_id, chunk_num) if int(chunk_num) == metadata.chunks: metadata = metadata._replace(all_chunks_received=True) with self.db_env.begin(db=self.metadata_db, write=True) as tx: tx.put(message_id.encode('ascii'), pickle.dumps(metadata)) return Response('', status=202) else: try: recipient = environ["HTTP_MEX_TO"] sender = environ["HTTP_MEX_FROM"] assert mailbox_id == sender except Exception as e: traceback.print_exc() return expectation_failed(e) message_id = self._new_message_id() self.save_chunk(environ, recipient, message_id, 1) headers = { _OPTIONAL_HEADERS[key]: value for key, value in environ.items() if key in _OPTIONAL_HEADERS } headers['Mex-Statustimestamp'] = datetime.datetime.now().strftime( TIMESTAMP_FORMAT) headers['Mex-Statussuccess'] = 'SUCCESS' headers[ 'Mex-Statusdescription'] = "Transferred to recipient mailbox" chunk_header = environ.get('HTTP_MEX_CHUNK_RANGE', '1:1') chunk_count = int(chunk_header.rsplit(':', 1)[1]) metadata = Metadata(chunk_count, recipient, headers, chunk_count == 1) with self.db_env.begin(write=True) as tx: tx.put(message_id.encode('ascii'), pickle.dumps(metadata), db=self.metadata_db) tx.put(recipient.encode('ascii'), message_id.encode('ascii'), dupdata=True, db=self.inbox_db) local_id = metadata.extra_headers.get('Mex-LocalID') if local_id: tracking_info = make_tracking_data(message_id, metadata) tx.put(local_id.encode('UTF-8'), json.dumps(tracking_info).encode('utf-8'), db=self.tracking_db) message = json.dumps({'messageID': message_id}) return Response(message, status=202)
def __call__(self, environ, start_response): pop_path_info(environ) return self.app(environ, start_response)
def attrib_values(environ, start_response): key = pop_path_info(environ) with eliot.start_action(action_type='api:get-attrib-values', key=key) as action: return db.attrib_values(key)