implement details endpoint in Python servers

[nominatim.git] / nominatim / server / sanic / server.py

diff --git a/nominatim/server/sanic/server.py b/nominatim/server/sanic/server.py
index 9c75327e19b12d4f6221e5854cc7efbfc4bcccf4..0bc7a1e7317d6daf17b8084f6880e302439468a2 100644 (file)
--- a/nominatim/server/sanic/server.py
+++ b/nominatim/server/sanic/server.py
@@ -2,61 +2,76 @@
 #
 # This file is part of Nominatim. (https://nominatim.org)
 #
-# Copyright (C) 2022 by the Nominatim developer community.
+# Copyright (C) 2023 by the Nominatim developer community.
 # For a full list of authors see the git log.
 """
 Server implementation using the sanic webserver framework.
 """
+from typing import Any, Optional, Mapping, Callable, cast, Coroutine
 from pathlib import Path
 
-import sanic
+from sanic import Request, HTTPResponse, Sanic
+from sanic.exceptions import SanicException
+from sanic.response import text as TextResponse
 
 from nominatim.api import NominatimAPIAsync
-from nominatim.apicmd.status import StatusResult
-import nominatim.result_formatter.v1 as formatting
+import nominatim.api.v1 as api_impl
+from nominatim.config import Configuration
 
-api = sanic.Blueprint('NominatimAPI')
+class ParamWrapper(api_impl.ASGIAdaptor):
+    """ Adaptor class for server glue to Sanic framework.
+    """
 
-CONTENT_TYPE = {
-  'text': 'text/plain; charset=utf-8',
-  'xml': 'text/xml; charset=utf-8'
-}
+    def __init__(self, request: Request) -> None:
+        self.request = request
 
-def usage_error(msg):
-    return sanic.response.text(msg, status=400)
 
+    def get(self, name: str, default: Optional[str] = None) -> Optional[str]:
+        return cast(Optional[str], self.request.args.get(name, default))
 
-def api_response(request, result):
-    body = request.ctx.formatter.format(result, request.ctx.format)
-    return sanic.response.text(body,
-                               content_type=CONTENT_TYPE.get(request.ctx.format, 'application/json'))
 
+    def get_header(self, name: str, default: Optional[str] = None) -> Optional[str]:
+        return cast(Optional[str], self.request.headers.get(name, default))
 
-@api.on_request
-async def extract_format(request):
-    request.ctx.formatter = request.app.ctx.formatters[request.route.ctx.result_type]
 
-    request.ctx.format = request.args.get('format', request.route.ctx.default_format)
-    if not request.ctx.formatter.supports_format(request.ctx.format):
-        return usage_error("Parameter 'format' must be one of: " +
-                           ', '.join(request.ctx.formatter.list_formats()))
+    def error(self, msg: str, status: int = 400) -> SanicException:
+        return SanicException(msg, status_code=status)
 
 
-@api.get('/status', ctx_result_type=StatusResult, ctx_default_format='text')
-async def status(request):
-    return api_response(request,await request.app.ctx.api.status())
+    def create_response(self, status: int, output: str,
+                        content_type: str) -> HTTPResponse:
+        return TextResponse(output, status=status, content_type=content_type)
 
 
-def get_application(project_dir: Path) -> sanic.Sanic:
-    app = sanic.Sanic("NominatimInstance")
+    def config(self) -> Configuration:
+        return cast(Configuration, self.request.app.ctx.api.config)
 
-    app.ctx.api = NominatimAPIAsync(project_dir)
-    app.ctx.formatters = {}
-    for rtype in (StatusResult, ):
-        app.ctx.formatters[rtype] = formatting.create(rtype)
 
-    app.blueprint(api)
+def _wrap_endpoint(func: api_impl.EndpointFunc)\
+       -> Callable[[Request], Coroutine[Any, Any, HTTPResponse]]:
+    async def _callback(request: Request) -> HTTPResponse:
+        return cast(HTTPResponse, await func(request.app.ctx.api, ParamWrapper(request)))
 
-    return app
+    return _callback
+
+
+def get_application(project_dir: Path,
+                    environ: Optional[Mapping[str, str]] = None) -> Sanic:
+    """ Create a Nominatim sanic ASGI application.
+    """
+    app = Sanic("NominatimInstance")
 
+    app.ctx.api = NominatimAPIAsync(project_dir, environ)
 
+    if app.ctx.api.config.get_bool('CORS_NOACCESSCONTROL'):
+        from sanic_cors import CORS # pylint: disable=import-outside-toplevel
+        CORS(app)
+
+    legacy_urls = app.ctx.api.config.get_bool('SERVE_LEGACY_URLS')
+    for name, func in api_impl.ROUTES:
+        endpoint = _wrap_endpoint(func)
+        app.add_route(endpoint, f"/{name}", name=f"v1_{name}_simple")
+        if legacy_urls:
+            app.add_route(endpoint, f"/{name}.php", name=f"v1_{name}_legacy")
+
+    return app