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 __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 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 __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 __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 __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 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 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 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 pop():
return wsgi.pop_path_info(env)
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)
