async def redirect_301(request): # $ requestHandler
if not "kwarg" in request.url.query:
raise web.HTTPMovedPermanently(
"/login"
) # $ HttpResponse HttpRedirectResponse mimetype=application/octet-stream redirectLocation="/login"
else:
raise web.HTTPMovedPermanently(
location="/logout"
) # $ HttpResponse HttpRedirectResponse mimetype=application/octet-stream redirectLocation="/logout"
def redirect(request,
router_name: str,
*,
permanent=False,
url: str = None,
reason="HttpFound",
**kwargs):
""" Redirect to given URL name
:param request: current request for web app
:param router_name: router name for creating redirect url (used if url not specified)
:param permanent: use permanent redirect
:param url: directly set url for redirecting
:param reason: Http reason for redirect moving ('HttpFound' by default)
:param kwargs: url-kwargs for forming redirecting url
:raises `aiohttp.web.HTTPMovedPermanently` `aiohttp.web.HTTPFound`
"""
if not url:
for key in kwargs.keys():
kwargs[key] = str(kwargs[key])
url = request.app.router[router_name].url_for(**kwargs)
if permanent:
raise web.HTTPMovedPermanently(url, reason=reason)
raise web.HTTPFound(url, reason=reason)
async def middleware_handler(request, handler):
try:
resp = await handler(request)
override = overrides.get(resp.status)
return await override(request) if override else resp
except web.HTTPNotFound:
index_resource = request.app.router['Index:get']
if request.path + '/' == index_resource.canonical:
logger.debug('Redirecting to index', path=request.path)
raise web.HTTPMovedPermanently(index_resource.url_for())
return await not_found_error(request)
except CompletedCaseError:
return await completed_case(request)
except InactiveIACError:
return await inactive_iac(request)
except ExerciseClosedError as ex:
return await ce_closed(request, ex.collection_exercise_id)
except InvalidEqPayLoad as ex:
return await eq_error(request, ex.message)
except ClientConnectionError as ex:
return await connection_error(request, ex.args[0])
except ClientConnectorError as ex:
return await connection_error(request, ex.os_error.strerror)
except ContentTypeError as ex:
return await payload_error(request, str(ex.request_info.url))
except ClientResponseError:
return await response_error(request)
def redirect(request, router_name, *, permanent=False, **kwargs):
""" Redirect to given URL name """
parts = kwargs.get('parts', {})
url = request.app.router[router_name].url_for(**parts)
if permanent:
raise web.HTTPMovedPermanently(url)
raise web.HTTPFound(url)
async def _request_handler(self, request):
if request.query_string:
raise web.HTTPBadRequest
self._windows_check(request.path)
path = self._re_pattern.sub('/', request.path)
if path != request.path:
raise web.HTTPMovedPermanently(path)
self._log(request.remote, '->', request.host, request.method,
request.path, request.headers.get('Range', ''))
rname, root, ro, to_handle = self._web_path(path, request.method)
if root is None:
return self._get_mainpage()
path = self._local_path_check(root / to_handle, root, True)
post_result = ''
if request.method == 'POST':
try:
post_result = await self._post_handler(request, path, root)
except web.HTTPException: # web.HTTPError would also work
raise
except Exception:
raise web.HTTPBadRequest
if path.is_dir():
return self._get_dir(request, rname, path, ro, root, post_result)
elif path.is_file():
return self._get_file(request, path)
else:
raise web.HTTPInternalServerError
async def middleware_handler(request, handler):
try:
resp = await handler(request)
override = overrides.get(resp.status)
return await override(request) if override else resp
except web.HTTPNotFound:
path_prefix = request.app['URL_PATH_PREFIX']
def path_starts_with(suffix):
return request.path.startswith(path_prefix + suffix)
index_resource = request.app.router['Start:get']
if path_starts_with('/ni'):
display_region = 'ni'
elif path_starts_with('/cy'):
display_region = 'cy'
else:
display_region = 'en'
if request.path + '/' == index_resource.canonical.replace(
'{display_region}', display_region):
logger.debug('redirecting to index',
client_ip=request['client_ip'],
client_id=request['client_id'],
trace=request['trace'],
path=request.path)
raise web.HTTPMovedPermanently(
index_resource.url_for(display_region=display_region))
return await not_found_error(request)
except web.HTTPForbidden:
return await forbidden(request)
except InvalidAccessCode:
return await invalid_access_code(request)
except SessionTimeout as ex:
return await session_timeout(request, ex.user_journey,
ex.sub_user_journey)
except TooManyRequests as ex:
return await too_many_requests(request, ex.sub_user_journey)
except TooManyRequestsWebForm:
return await too_many_requests_web_form(request)
except TooManyRequestsEQLaunch:
return await too_many_requests_eq_launch(request)
except InactiveCaseError as ex:
return await inactive_case(request, ex.case_type)
except ExerciseClosedError as ex:
return await ce_closed(request, ex.collection_exercise_id)
except InvalidEqPayLoad as ex:
return await eq_error(request, ex.message)
except ClientConnectionError as ex:
return await connection_error(request, ex.args[0])
except ClientConnectorError as ex:
return await connection_error(request, ex.os_error.strerror)
except ContentTypeError as ex:
return await payload_error(request, str(ex.request_info.url))
except KeyError as error:
return await key_error(request, error)
except ClientResponseError as ex:
return await response_error(request, ex)
def remove_trailing_slashes_middleware(self, request, handler):
path = request.url.path
if path.endswith("/") and len(path) > 1:
while path.endswith("/"):
path = path[:-1]
if len(path) == 0:
path = "/"
return web.HTTPMovedPermanently(path)
res = yield from handler(request)
return res
async def get(self):
"""Reply to HTTP GET request."""
# if the train number is specified through
# a GET parameter, redirect to the perma link
self.train_number = self.request.GET.get('train', None)
if self.train_number:
return web.HTTPMovedPermanently(
'/%s/train/%s' % (self.request.language, self.train_number))
self.train_number = self.request.match_info.get('train')
return await super(TrainView, self).get()
def _get_dir(self, request, rname, path, ro, root, post_result):
if not request.path.endswith('/'):
raise web.HTTPMovedPermanently(request.path + '/')
if post_result:
post_result = self._html8.format(post_result)
resp = [
self._html0,
self._html1.format(
html.escape(
pathlib.Path(rname, path.relative_to(root)).as_posix()),
post_result),
self._html2.format('<b>Name</b>', '<b>Size</b>')
]
body = [[], [], {}]
# python 3.6 dict: keys are kept in insertion order
try:
resp.append(
self._html2.format(self._html7.format('../', '../'), 'DIR'))
for item in path.iterdir():
if item.is_symlink():
body[0].append(item.name)
elif item.is_dir():
body[1].append(item.name)
elif item.is_file():
body[2][item.name] = item.stat().st_size
else:
raise web.HTTPInternalServerError
except PermissionError:
raise web.HTTPForbidden
resp.extend(
self._html2.format(
self._html7.format(parse.quote(item_name),
html.escape(item_name + '@')), 'LNK')
for item_name in sorted(body[0]))
resp.extend(
self._html2.format(
self._html7.format(parse.quote(item_name + '/'),
html.escape(item_name + '/')), 'DIR')
for item_name in sorted(body[1]))
resp.extend(
self._html2.format(
self._html7.format(parse.quote(item_name),
html.escape(item_name)), size)
for item_name, size in sorted(body[2].items()))
resp.append(self._html3)
if not ro:
resp.append(self._html4)
# resp.append(self._html7.format('/', 'Home Page'))
resp.append(self._html5)
return web.Response(text='\n'.join(resp), content_type='text/html')
def normalize_path(raw_path: str):
segments = raw_path.split('/')
resolved = []
for segment in segments:
if segment == "..":
if resolved:
resolved.pop()
elif segment != ".":
resolved.append(segment)
# Remove any null segments or trailing slashes, even though they're technically different paths
resolved = [r for r in resolved if len(r)]
norm_path = "/" + "/".join(resolved)
if norm_path != raw_path:
raise web.HTTPMovedPermanently(location=norm_path)
return resolved
async def documentation(request):
project_name = request.match_info["project_name"]
path = request.match_info.get("path", "")
if project_name in request.app["redirects"]:
location = request.app["redirects"][project_name]["base_uri"]
if request.app["redirects"][project_name]["include_path"]:
location = f"{location}/{path}"
return web.Response(
status=302,
headers={
"Location": location,
}
)
path = f"{project_name}/{path}"
if path.endswith("/"):
path += "index.html"
bucket = request.app["settings"]["docs_bucket"]
session = request.app["boto.session"]
async with session.create_client('s3', config=ANON_CONFIG) as s3:
try:
key = await fetch_key(s3, request, bucket, path)
except botocore.exceptions.ClientError:
try:
key = await fetch_key(s3, request, bucket, path + "/index.html")
except botocore.exceptions.ClientError:
return web.Response(status=404)
else:
return web.HTTPMovedPermanently(location="/" + path + "/")
content_type, content_encoding = mimetypes.guess_type(path)
response = web.StreamResponse(status=200, reason='OK')
response.content_type = content_type
response.content_encoding = content_encoding
body = key['Body']
await response.prepare(request)
while True:
data = await body.read(4096)
await response.write(data)
await response.drain()
if not data:
body.close()
break
return response
async def get(self):
"""
Return redirect to a URL specified by a key.
"""
key: str = self.request.match_info.get("key")
if key is None:
return web.json_response(
{
"ok": False,
"errors": "A link with a given key was not found."
},
status=HTTPStatus.NOT_FOUND.value,
)
link = await get_link(self.client, key)
raise web.HTTPMovedPermanently(link)
async def normalize_postcode_middleware(request, handler):
"""
If there is a postcode in the url it validates and normalizes it.
"""
postcode: Optional[str] = request.match_info.get('postcode', None)
if postcode is None or postcode == "random":
return await handler(request)
elif not is_uk_postcode(postcode):
raise web.HTTPNotFound(text="Invalid Postcode")
postcode_processed = postcode.upper().replace(" ", "")
if postcode_processed == postcode:
return await handler(request)
else:
url_name = request.match_info.route.name
url = request.app.router[url_name]
params = dict(request.match_info)
params['postcode'] = postcode_processed
raise web.HTTPMovedPermanently(str(url.url_for(**params)))
def get(obj):
if not DIMENSIONS:
return
icon_path = _get_best_fit(obj.extension, obj.width, obj.height)
if icon_path is None:
return
if ICON_REDIRECT:
# Redirect browser to icon.
url = '%s/%s' % (ICON_REDIRECT.rstrip('/'), icon_path)
raise web.HTTPMovedPermanently(location=url)
# Convert to full local path.
icon_path = pathjoin(ICON_ROOT, icon_path)
LOGGER.debug('Using icon: %s', icon_path)
obj.src = PathModel(icon_path)
if ICON_RESIZE:
# Resize or convert the icon to the desired size / format.
Backend.preview(obj)
return True
def _web_path(self, pathstr, method=None):
if not pathstr.startswith(self._prefix):
raise web.HTTPMovedPermanently(self._prefix)
pathstr = pathstr[len(self._prefix):]
share_name, sep, rest = pathstr.partition('/')
if len(share_name) == 0:
assert len(sep) == 0 and len(rest) == 0
root = None
elif share_name in self._fd:
root = self._fd[share_name]
else:
raise web.HTTPNotFound
if callable(root):
return root
readonly = root is None or share_name in self._ro
if method is not None:
if readonly and method != 'GET':
raise web.HTTPMethodNotAllowed(method, ['GET'])
if method != 'GET' and method != 'POST':
raise web.HTTPMethodNotAllowed(method, ['GET', 'POST'])
rest = pathlib.Path(rest)
if rest.anchor:
raise web.HTTPForbidden
return share_name, root, readonly, rest
async def handler(request):
return web.HTTPMovedPermanently(
location=subapp.router['name'].url_for(filename=fname))
async def handler(request):
return web.HTTPMovedPermanently(
location=subapp.router['name'].url_for(part='final'))
def redirect(request, router_name, *, permanent=False, **kwargs):
""" Редирект """
url = request.app.router[router_name].url(**kwargs)
if permanent:
raise web.HTTPMovedPermanently(url)
raise web.HTTPFound(url)
def function146(arg1145):
raise web.HTTPMovedPermanently(location='/path')
async def index(request):
"""Redirects to the GitHub repo's page"""
return web.HTTPMovedPermanently(
'https://github.com/atbaker/twiml-boomerang')
async def handler(request):
raise web.HTTPMovedPermanently(
location=subapp.router['name'].url_for())
r = await self.url_conn.insert_authorized_key(
user,
super_user=bool(field.get('super_user', 'false').lower()))
await self.redis.sadd('us_auth', r)
return web.json_response(dict(status=200, result=r))
if self.debug_mode:
logger.debug('Post user => %d', user)
return web.HTTPBadRequest()
async def handle_redirect(self, request: web.Request) -> web.Response:
if not (url := request.match_info.get('url')):
return await self.handle_help_page(request)
if redis_result := await self.redis.get(f'us_{url}'):
url = redis_result.decode()
if url != 'Null':
return web.HTTPMovedPermanently(url)
return web.HTTPBadRequest()
if result := await self.url_conn.query_url(url):
asyncio.run_coroutine_threadsafe(
self.save_query_result(url, result), asyncio.get_event_loop())
return web.HTTPMovedPermanently(url)
asyncio.run_coroutine_threadsafe(self.save_query_result(url, "Null"),
asyncio.get_event_loop())
return web.HTTPBadRequest()
async def handle_create_link(self, request: web.Request) -> web.Response:
# Authorization: Bearer user_id:auth_string
if not isinstance(bearer := await self.verify_identify(request), str):
return bearer
data = await request.post()
if not (url := data.get('url')):
def func(request):
raise web.HTTPMovedPermanently(location='/')
async def documentation_top(request):
project_name = request.match_info["project_name"]
return web.HTTPMovedPermanently(location=f"/{project_name}/")
async def handle_add_slash(self, request):
raise web.HTTPMovedPermanently(
str(request.rel_url.with_path(request.rel_url.path + '/')))
def root(request):
return web.HTTPMovedPermanently("/static/index.html")
async def get_index(request):
return web.HTTPMovedPermanently(location='/static/index.html')
def redirect(request):
raise web.HTTPMovedPermanently(
location=self.base_path + console_ui_path + '/'
)
def handler(request):
raise web.HTTPMovedPermanently(location='/path')
async def _redirect(request: web.Request) -> web.Response:
return web.HTTPMovedPermanently(f"{request.path}/")
