def test_path_info_and_script_name_fetching(self):
env = create_environ(u'/\N{SNOWMAN}', u'http://example.com/\N{COMET}/')
self.assert_equal(wsgi.get_path_info(env), u'/\N{SNOWMAN}')
self.assert_equal(wsgi.get_path_info(env, charset=None),
u'/\N{SNOWMAN}'.encode('utf-8'))
self.assert_equal(wsgi.get_script_name(env), u'/\N{COMET}')
self.assert_equal(wsgi.get_script_name(env, charset=None),
u'/\N{COMET}'.encode('utf-8'))
def test_path_info_and_script_name_fetching():
env = create_environ(u'/\N{SNOWMAN}', u'http://example.com/\N{COMET}/')
assert wsgi.get_path_info(env) == u'/\N{SNOWMAN}'
assert wsgi.get_path_info(env,
charset=None) == u'/\N{SNOWMAN}'.encode('utf-8')
assert wsgi.get_script_name(env) == u'/\N{COMET}'
assert wsgi.get_script_name(env,
charset=None) == u'/\N{COMET}'.encode('utf-8')
def __call__(self, environ, start_response):
url_to_annotate = wsgi.get_path_info(environ)[1:]
if not url_to_annotate:
# This is our own landing page "/", no need to check this
return self._application(environ, start_response)
parsed_url = urlparse(url_to_annotate)
if not parsed_url.scheme:
url_to_annotate = "http://" + url_to_annotate
try:
hits = self._checkmate.check_url(url_to_annotate)
except CheckmateException as err:
LOG.warning(
"Failed to check url against checkmate with error: {}".format(
err))
hits = None
if hits:
template_name, status = self.templates.get(hits.reason_codes[0],
self.templates["other"])
template = self._jinja_env.get_template(template_name).render(
url_to_annotate=url_to_annotate)
resp = Response(template, status=status, mimetype="text/html")
return resp(environ, start_response)
return self._application(environ, start_response)
def __call__(self, environ, start_response):
if self.context is None:
self.context = self.site.build()
for input_file in self.context.input_files:
self.extra_files.append(
os.path.join(self.site.source_path, input_file))
cleaned_path = get_path_info(environ)
cleaned_path = cleaned_path.lstrip('/')
cleaned_path = '/' + cleaned_path
static_file_path = None
if cleaned_path.lstrip('/') in self.context.output_files:
static_file_path = cleaned_path
elif cleaned_path.endswith('/'):
try_cleaned_path = cleaned_path + 'index.html'
if try_cleaned_path.lstrip('/') in self.context.output_files:
static_file_path = try_cleaned_path
if static_file_path is None:
return self.application(environ, start_response)
real_path = os.path.join(self.context.site.build_path,
static_file_path.lstrip('/'))
guessed_type = mimetypes.guess_type(real_path)
mime_type = guessed_type[0] or 'text/plain'
file_size = int(os.path.getsize(real_path))
headers = [
('Content-Type', mime_type),
('Content-Length', str(file_size)),
]
start_response('200 OK', headers)
return wrap_file(environ, open(real_path, 'rb'))
def __call__(self, environ, start_response):
# Parse the URL and referrer
request_path = wsgi.get_path_info(environ)
via_host = environ.get("HTTP_HOST")
classified_url = ClassifiedURL.classify(request_path, via_host, assume_via=True)
classified_referrer = ClassifiedURL.classify(
environ.get("HTTP_REFERER"), via_host
)
# Determine which urls should be run against checkmate (if any)
full_check, partial_check, rule_type = self._get_urls_to_check(
classified_url, classified_referrer
)
# Apply the checks
for url_to_check, allow_all in ((full_check, False), (partial_check, True)):
if not url_to_check:
# No check of this type requested
continue
blocked = self._check_url(url_to_check.proxied_url, allow_all=allow_all)
if not blocked:
continue
response = Response(
"",
status="307 Temporary Redirect",
headers=[("Location", blocked.presentation_url)],
)
return response(environ, start_response)
return self._application(environ, start_response)
def on_ext(self, request):
if request.method == 'POST':
r = {'result': None, 'error': None}
method = get_path_info(request.environ)
data = request.get_data()
if type(data) != str:
data = to_unicode(data, 'utf-8')
params = json.loads(data)
task = self.get_task()
try:
data = None
if self.under_maintenance:
status = common.UNDER_MAINTAINANCE
elif task.on_ext_request:
status = common.RESPONSE
self._busy += 1
try:
data = task.on_ext_request(task, method, params)
finally:
self._busy -= 1
else:
status = None
r['result'] = {'status': status, 'data': data, 'version': task.version}
except AbortException as e:
traceback.print_exc()
r['result'] = {'data': [None, error_message(e)]}
r['error'] = error_message(e)
except Exception as e:
traceback.print_exc()
#~ if common.SETTINGS['DEBUGGING']:
#~ raise
r['result'] = {'data': [None, error_message(e)]}
r['error'] = error_message(e)
return self.create_post_response(request, r)
def __call__(self, environ, start_response):
self._update_blocklist()
url_to_annotate = wsgi.get_path_info(environ)[1:]
parsed_url = urlparse(url_to_annotate)
if not parsed_url.scheme:
url_to_annotate = "http://" + url_to_annotate
parsed_url = urlparse(url_to_annotate)
hostname_to_annotate = parsed_url.hostname
if hostname_to_annotate in self._blocked_domains:
reason = self._blocked_domains[hostname_to_annotate]
if reason == "publisher-blocked":
template_name = "disallow_access.html.jinja2"
status = 451
else:
template_name = "could_not_process.html.jinja2"
status = 200
template = self._jinja_env.get_template(template_name).render(
url_to_annotate=url_to_annotate
)
resp = Response(template, status=status, mimetype="text/html")
return resp(environ, start_response)
return self._application(environ, start_response)
def on_ext(self, request):
if request.method == 'POST':
r = {'result': None, 'error': None}
method = get_path_info(request.environ)
params = json.loads(request.get_data())
task = self.get_task()
try:
data = None
if task.on_ext_request:
data = task.on_ext_request(task, method, params)
r['result'] = {
'status': common.RESPONSE,
'data': data,
'version': task.version
}
except AbortException as e:
traceback.print_exc()
r['result'] = {'data': [None, e.message]}
r['error'] = e.message
except Exception as e:
traceback.print_exc()
if common.SETTINGS['DEBUGGING'] and task_id != 0:
raise
r['result'] = {'data': [None, e.message]}
r['error'] = e.message
return self.create_post_response(request, r)
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 __call__(self, environ, start_response):
"""Returns application instance respective to the parliament in
the URL.
"""
segments = get_path_info(environ).strip('/').split('/', 2)
if len(segments) < 2:
app = hateoas_app
else:
pfx = segments[0] + '/' + segments[1]
app = self.instances.get(pfx, NotFound())
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):
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):
# prefix = peek_path_info(environ)
# [/root]/prefix[/more] -> /prefix[/more]
path = get_path_info(environ).replace(self.root, "/")
handler = self.find_handler(path)
app = self.get_application(handler)
# print(handler, app, path)
# pop_path_info(environ)
if app is not None and self.root != "/":
environ["PATH_INFO"] = environ["PATH_INFO"].replace(self.root, "/")
if "REQUEST_URI" in environ:
environ["REQUEST_URI"] = environ["REQUEST_URI"].replace(self.root, "/")
# environ['SCRIPT_NAME'] = environ['SCRIPT_NAME'] + self.root[:-1]
if app is None:
app = self.default_app
return app(environ, start_response)
def __call__(self, environ, start_response):
url_to_annotate = wsgi.get_path_info(environ)[1:]
parsed_url = urlparse(url_to_annotate)
if not parsed_url.scheme:
url_to_annotate = "http://" + url_to_annotate
parsed_url = urlparse(url_to_annotate)
hostname_to_annotate = parsed_url.hostname
for _d in self._domains:
if hostname_to_annotate and hostname_to_annotate == _d['domain']:
template = self._jinja_env.get_template(_d['template']).render(url_to_annotate=url_to_annotate)
resp = Response(template,
status=_d['status'], mimetype='text/html')
return resp(environ, start_response)
return self._application(environ, start_response)
def on_ext(self, request):
if request.method == 'POST':
r = {'result': None, 'error': None}
method = get_path_info(request.environ)
data = request.get_data()
if type(data) != str:
data = to_unicode(data, 'utf-8')
try:
params = json.loads(data)
except:
params = None
if self.task:
try:
data = None
if self.under_maintenance:
status = consts.UNDER_MAINTAINANCE
elif self.task.on_ext_request:
status = consts.RESPONSE
self._busy += 1
try:
data = self.task.on_ext_request(
self.task, method, params)
finally:
self._busy -= 1
else:
status = None
r['result'] = {
'status': status,
'data': data,
'modification': consts.MODIFICATION
}
except AbortException as e:
traceback.print_exc()
r['result'] = {'data': [None, error_message(e)]}
r['error'] = error_message(e)
except Exception as e:
traceback.print_exc()
r['result'] = {'data': [None, error_message(e)]}
r['error'] = error_message(e)
else:
r['result'] = {
'status': self.state,
'data': None,
'modification': None
}
return self.create_post_response(request, r)
def __call__(self, environ, start_response):
url_to_annotate = wsgi.get_path_info(environ)[1:]
parsed_url = urlparse(url_to_annotate)
if not parsed_url.scheme:
url_to_annotate = "http://" + url_to_annotate
parsed_url = urlparse(url_to_annotate)
hostname_to_annotate = parsed_url.hostname
for _d in self._domains:
if hostname_to_annotate and hostname_to_annotate == _d["domain"]:
template = self._jinja_env.get_template(_d["template"]).render(
url_to_annotate=url_to_annotate
)
resp = Response(template, status=_d["status"], mimetype="text/html")
return resp(environ, start_response)
return self._application(environ, start_response)
def on_ext(self, request):
if request.method == "POST":
r = {"result": None, "error": None}
method = get_path_info(request.environ)
params = json.loads(request.get_data())
user_id = None
task_id = None
item_id = None
ext = True
try:
r["result"] = self.process_request(request.environ, method, user_id, task_id, item_id, params, ext)
except AbortException, e:
print traceback.format_exc()
r["result"] = {"data": [None, e.message]}
r["error"] = e.message
except Exception, e:
print traceback.format_exc()
if common.SETTINGS["DEBUGGING"] and task_id != 0:
raise
r["result"] = {"data": [None, e.message]}
r["error"] = e.message
def on_ext(self, request):
if request.method == 'POST':
r = {'result': None, 'error': None}
method = get_path_info(request.environ)
params = json.loads(request.get_data())
user_id = None
task_id = None
item_id = None
ext = True
try:
r['result'] = self.process_request(request.environ,
method, user_id, task_id, item_id, params, ext)
except AbortException, e:
print traceback.format_exc()
r['result'] = None, e.message
r['error'] = e.message
except Exception, e:
print traceback.format_exc()
if common.SETTINGS['DEBUGGING']:
raise
r['result'] = None, e.message
r['error'] = e.message
def on_ext(self, request):
if request.method == 'POST':
r = {'result': None, 'error': None}
method = get_path_info(request.environ)
params = json.loads(request.get_data())
user_id = None
task_id = None
item_id = None
ext = True
try:
r['result'] = self.process_request(request.environ,
method, user_id, task_id, item_id, params, ext)
except AbortException, e:
print traceback.format_exc()
r['result'] = {'data': [None, e.message]}
r['error'] = e.message
except Exception, e:
print traceback.format_exc()
if common.SETTINGS['DEBUGGING'] and task_id != 0:
raise
r['result'] = {'data': [None, e.message]}
r['error'] = e.message
def on_ext(self, request):
if request.method == 'POST':
r = {'result': None, 'error': None}
method = get_path_info(request.environ)
data = request.get_data()
if type(data) != str:
data = to_unicode(data, 'utf-8')
try:
params = json.loads(data)
except:
params = None
if self.task:
try:
data = None
if self.under_maintenance:
status = common.UNDER_MAINTAINANCE
elif self.task.on_ext_request:
status = common.RESPONSE
self._busy += 1
try:
data = self.task.on_ext_request(self.task, method, params)
finally:
self._busy -= 1
else:
status = None
r['result'] = {'status': status, 'data': data, 'version': self.task.version}
except AbortException as e:
traceback.print_exc()
r['result'] = {'data': [None, error_message(e)]}
r['error'] = error_message(e)
except Exception as e:
traceback.print_exc()
r['result'] = {'data': [None, error_message(e)]}
r['error'] = error_message(e)
else:
r['result'] = {'status': self.state, 'data': None, 'version': None}
return self.create_post_response(request, r)
def test_path_info_and_script_name_fetching(self):
env = create_environ(u'/\N{SNOWMAN}', u'http://example.com/\N{COMET}/')
self.assert_equal(wsgi.get_path_info(env), u'/\N{SNOWMAN}')
self.assert_equal(wsgi.get_path_info(env, charset=None), u'/\N{SNOWMAN}'.encode('utf-8'))
self.assert_equal(wsgi.get_script_name(env), u'/\N{COMET}')
self.assert_equal(wsgi.get_script_name(env, charset=None), u'/\N{COMET}'.encode('utf-8'))
def test_path_info_and_script_name_fetching():
env = create_environ(u'/\N{SNOWMAN}', u'http://example.com/\N{COMET}/')
assert wsgi.get_path_info(env) == u'/\N{SNOWMAN}'
assert wsgi.get_path_info(env, charset=None) == u'/\N{SNOWMAN}'.encode('utf-8')
assert wsgi.get_script_name(env) == u'/\N{COMET}'
assert wsgi.get_script_name(env, charset=None) == u'/\N{COMET}'.encode('utf-8')
def test_path_info_and_script_name_fetching(self):
env = create_environ(u"/\N{SNOWMAN}", u"http://example.com/\N{COMET}/")
self.assert_equal(wsgi.get_path_info(env), u"/\N{SNOWMAN}")
self.assert_equal(wsgi.get_path_info(env, charset=None), u"/\N{SNOWMAN}".encode("utf-8"))
self.assert_equal(wsgi.get_script_name(env), u"/\N{COMET}")
self.assert_equal(wsgi.get_script_name(env, charset=None), u"/\N{COMET}".encode("utf-8"))
def __call__(self, environ, start_response):
if wsgi.get_path_info(environ).startswith(self._prefixes):
resp = Response(self._template, status=451, mimetype='text/html')
return resp(environ, start_response)
return self.application(environ, start_response)
def test_path_info_and_script_name_fetching():
env = create_environ(u"/\N{SNOWMAN}", u"http://example.com/\N{COMET}/")
assert wsgi.get_path_info(env) == u"/\N{SNOWMAN}"
assert wsgi.get_path_info(env, charset=None) == u"/\N{SNOWMAN}".encode("utf-8")
assert wsgi.get_script_name(env) == u"/\N{COMET}"
assert wsgi.get_script_name(env, charset=None) == u"/\N{COMET}".encode("utf-8")
def test_path_info_and_script_name_fetching():
env = create_environ("/\N{SNOWMAN}", "http://example.com/\N{COMET}/")
assert wsgi.get_path_info(env) == "/\N{SNOWMAN}"
assert wsgi.get_path_info(env, charset=None) == "/\N{SNOWMAN}".encode()
assert wsgi.get_script_name(env) == "/\N{COMET}"
assert wsgi.get_script_name(env, charset=None) == "/\N{COMET}".encode()
