The trickiest part here is the 404 logic. It's spread out through a couple of places right now. It's in datasette.utils.asgi.AsgiRouter:

datasette/datasette/utils/asgi.py

Lines 98 to 134 in 227bb3e

    
           class AsgiRouter: 
        
               def __init__(self, routes=None): 
        
                   routes = routes or [] 
        
                   self.routes = [ 
        
                       # Compile any strings to regular expressions 
        
                       ((re.compile(pattern) if isinstance(pattern, str) else pattern), view) 
        
                       for pattern, view in routes 
        
                   ] 
        
               async def __call__(self, scope, receive, send): 
        
                   # Because we care about "foo/bar" v.s. "foo%2Fbar" we decode raw_path ourselves 
        
                   path = scope["path"] 
        
                   raw_path = scope.get("raw_path") 
        
                   if raw_path: 
        
                       path = raw_path.decode("ascii") 
        
                   return await self.route_path(scope, receive, send, path) 
        
               async def route_path(self, scope, receive, send, path): 
        
                   for regex, view in self.routes: 
        
                       match = regex.match(path) 
        
                       if match is not None: 
        
                           new_scope = dict(scope, url_route={"kwargs": match.groupdict()}) 
        
                           try: 
        
                               return await view(new_scope, receive, send) 
        
                           except Exception as exception: 
        
                               return await self.handle_500(scope, receive, send, exception) 
        
                   return await self.handle_404(scope, receive, send) 
        
               async def handle_404(self, scope, receive, send): 
        
                   await send( 
        
                       { 
        
                           "type": "http.response.start", 
        
                           "status": 404, 
        
                           "headers": [[b"content-type", b"text/html"]], 
        
                       } 
        
                   ) 
        
                   await send({"type": "http.response.body", "body": b"<h1>404</h1>"})

Then also in the `DatasetteRouter subclass of that:

datasette/datasette/app.py

Lines 736 to 757 in 227bb3e

    
           class DatasetteRouter(AsgiRouter): 
        
               def __init__(self, datasette, routes): 
        
                   self.ds = datasette 
        
                   super().__init__(routes) 
        
               async def route_path(self, scope, receive, send, path): 
        
                   # Strip off base_url if present before routing 
        
                   base_url = self.ds.config("base_url") 
        
                   if base_url != "/" and path.startswith(base_url): 
        
                       path = "/" + path[len(base_url) :] 
        
                   return await super().route_path(scope, receive, send, path) 
        
               async def handle_404(self, scope, receive, send): 
        
                   # If URL has a trailing slash, redirect to URL without it 
        
                   path = scope.get("raw_path", scope["path"].encode("utf8")) 
        
                   if path.endswith(b"/"): 
        
                       path = path.rstrip(b"/") 
        
                       if scope["query_string"]: 
        
                           path += b"?" + scope["query_string"] 
        
                       await asgi_send_redirect(send, path.decode("latin1")) 
        
                   else: 
        
                       await super().handle_404(scope, receive, send)

	class AsgiRouter:
	def __init__(self, routes=None):
	routes = routes or []
	self.routes = [
	# Compile any strings to regular expressions
	((re.compile(pattern) if isinstance(pattern, str) else pattern), view)
	for pattern, view in routes
	]

	async def __call__(self, scope, receive, send):
	# Because we care about "foo/bar" v.s. "foo%2Fbar" we decode raw_path ourselves
	path = scope["path"]
	raw_path = scope.get("raw_path")
	if raw_path:
	path = raw_path.decode("ascii")
	return await self.route_path(scope, receive, send, path)

	async def route_path(self, scope, receive, send, path):
	for regex, view in self.routes:
	match = regex.match(path)
	if match is not None:
	new_scope = dict(scope, url_route={"kwargs": match.groupdict()})
	try:
	return await view(new_scope, receive, send)
	except Exception as exception:
	return await self.handle_500(scope, receive, send, exception)
	return await self.handle_404(scope, receive, send)

	async def handle_404(self, scope, receive, send):
	await send(
	{
	"type": "http.response.start",
	"status": 404,
	"headers": [[b"content-type", b"text/html"]],
	}
	)
	await send({"type": "http.response.body", "body": b"<h1>404</h1>"})

	class DatasetteRouter(AsgiRouter):
	def __init__(self, datasette, routes):
	self.ds = datasette
	super().__init__(routes)

	async def route_path(self, scope, receive, send, path):
	# Strip off base_url if present before routing
	base_url = self.ds.config("base_url")
	if base_url != "/" and path.startswith(base_url):
	path = "/" + path[len(base_url) :]
	return await super().route_path(scope, receive, send, path)

	async def handle_404(self, scope, receive, send):
	# If URL has a trailing slash, redirect to URL without it
	path = scope.get("raw_path", scope["path"].encode("utf8"))
	if path.endswith(b"/"):
	path = path.rstrip(b"/")
	if scope["query_string"]:
	path += b"?" + scope["query_string"]
	await asgi_send_redirect(send, path.decode("latin1"))
	else:
	await super().handle_404(scope, receive, send)

Uh oh!

Mechanism for adding arbitrary pages like /about #648

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions