@fireemu/darwin-arm64 0.43.0 → 0.44.0

package/bin/runner-python/fireemu_runner/serve.py

@@ -1,4 +1,4 @@
-"""The HTTP server for `onRequest` and `onCall` functions.
+"""The HTTP server for `onRequest`, `onCall`, task queue and Auth blocking functions.
 
 The daemon proxies `/<project>/<region>/<name>/...` here with the `x-fireemu-runner-secret` header
 (`crates/fireemu-adapter-functions/src/http.rs`, `tools/runner-node/http-admission.mjs`). The
@@ -6,16 +6,22 @@ function sees the path below its mount point, as it does in production, and answ
 `flask.Request` handlers the SDK wraps. An unhandled error is functions-framework's crash response.
 """
 
+import contextlib
 import hmac
 import os
+import sys
 
 import flask
 from functions_framework import crash_handler, read_request
 from werkzeug.serving import WSGIRequestHandler, make_server
 
+from .diagnostics import ASYNC_HANDLER, describe, is_async_handler
+from .environment import EnvironmentGate
 from .manifest import DEFAULT_REGION
 
 SECRET_ENVIRON_KEY = "HTTP_X_FIREEMU_RUNNER_SECRET"
+# Task queue and Auth blocking functions enter through the HTTP wrapper as well (the Node runner's `signatureType`).
+HTTP_TRIGGERS = frozenset(("http", "tasks", "blockingAuth"))
 _METHODS = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
 
 
@@ -33,20 +39,68 @@ def _flask_app() -> flask.Flask:
     return app
 
 
+class ResponseBodyFailed(Exception):
+    """A response body failed while it was being sent. The details were logged inside the function's environment."""
+
+
+def _log_failure(name: str, error: BaseException) -> None:
+    diagnostic, _ = describe(error)
+    sys.stderr.write(f"[functions] {name}: {diagnostic[:8192]}\n")
+
+
+class _HeldBody:
+    """A response body that keeps its function's environment until the body is finished, whatever happens to it.
+
+    Closing the body, and running the callbacks `Response.call_on_close` registered, is user code: if it raises the
+    gate must still be released, or the process is locked with a secret in its environment. Errors are described
+    here, while the environment is still held, and the server sees only a plain exception.
+    """
+
+    def __init__(self, body, held: contextlib.ExitStack, name: str):
+        self._body = body
+        self._iterator = iter(body)
+        self._held = held
+        self._name = name
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            return next(self._iterator)
+        except StopIteration:
+            raise
+        except BaseException as error:
+            _log_failure(self._name, error)
+            raise ResponseBodyFailed(type(error).__name__) from None
+
+    def close(self):
+        try:
+            close = getattr(self._body, "close", None)
+            if close is not None:
+                close()
+        except BaseException as error:  # the response has been sent; there is nobody to tell but the log
+            _log_failure(self._name, error)
+        finally:
+            self._held.close()
+
+
 class RunnerRouter:
     """Admission and routing in front of the Flask app."""
 
-    def __init__(self, functions: dict, manifest: dict, project: str, secret: str):
+    def __init__(self, functions: dict, manifest: dict, project: str, secret: str, gate: EnvironmentGate | None = None):
         self._app = _flask_app()
+        self._gate = gate if gate is not None else EnvironmentGate({})
         self._project = project
         self._secret = secret.encode()
         self._routes = {}
         for spec in manifest["functions"]:
-            if spec["trigger"]["type"] == "http":
+            if spec["trigger"]["type"] in HTTP_TRIGGERS:
                 self._routes[spec["name"]] = (
                     spec.get("region", DEFAULT_REGION),
                     functions[spec["entryPoint"]],
                     spec["entryPoint"],
+                    spec.get("platformOptions", {}).get("secrets"),
                 )
 
     @staticmethod
@@ -57,6 +111,10 @@ class RunnerRouter:
 
     def __call__(self, environ, start_response):
         presented = environ.pop(SECRET_ENVIRON_KEY, "").encode()
+        if not self._secret:
+            # A runner with no secret would accept any request without the header (an empty value equals an empty
+            # secret). The Node runner answers every request this way (`http-admission.mjs`).
+            return self._plain(start_response, "500 Internal Server Error", "FIREEMU_RUNNER_SECRET is required")
         if not hmac.compare_digest(presented, self._secret):
             return self._plain(start_response, "403 Forbidden", "forbidden")
         parts = environ.get("PATH_INFO", "").split("/")
@@ -70,12 +128,26 @@ class RunnerRouter:
         environ["SCRIPT_NAME"] = environ.get("SCRIPT_NAME", "") + "/".join(parts[:4])
         environ["PATH_INFO"] = "/" + "/".join(parts[4:])
         environ["fireemu.function"] = route[1]
-        # The variables a production instance has from its start name the function it serves. One process
-        # serves the whole codebase here, so they name the call that started most recently, as for events.
-        os.environ["FUNCTION_TARGET"] = route[2]
-        os.environ["FUNCTION_SIGNATURE_TYPE"] = "http"
-        os.environ["K_SERVICE"] = name
-        return self._app(environ, start_response)
+        if is_async_handler(route[1]):
+            # Production answers 500 as well (the coroutine is not a response); this says why.
+            sys.stderr.write(f"[functions] {name}: {ASYNC_HANDLER}\n")
+            return self._plain(start_response, "500 Internal Server Error", ASYNC_HANDLER)
+        # The environment this function is entitled to is held until its response is finished, a streamed body
+        # included: the secrets it declares are in the process environment for exactly that long.
+        held = contextlib.ExitStack()
+        held.enter_context(self._gate.hold(route[3]))
+        try:
+            # The variables a production instance has from its start name the function it serves. One process
+            # serves the whole codebase here, so they name the call that started most recently, as for events.
+            os.environ["FUNCTION_TARGET"] = route[2]
+            os.environ["FUNCTION_SIGNATURE_TYPE"] = "http"
+            os.environ["K_SERVICE"] = name
+            body = self._app(environ, start_response)
+        except BaseException as error:
+            _log_failure(name, error)
+            held.close()
+            raise ResponseBodyFailed(type(error).__name__) from None
+        return _HeldBody(body, held, name)
 
 
 class _QuietHandler(WSGIRequestHandler):
@@ -83,9 +155,9 @@ class _QuietHandler(WSGIRequestHandler):
         pass
 
 
-def start_server(functions: dict, manifest: dict, secret: str):
+def start_server(functions: dict, manifest: dict, secret: str, gate: EnvironmentGate | None = None):
     """Starts the server on a free loopback port; returns `(server, port)`."""
-    router = RunnerRouter(functions, manifest, os.environ.get("GCLOUD_PROJECT", ""), secret)
+    router = RunnerRouter(functions, manifest, os.environ.get("GCLOUD_PROJECT", ""), secret, gate)
     server = make_server("127.0.0.1", 0, router, threaded=True, request_handler=_QuietHandler)
     import threading
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireemu/darwin-arm64",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "The fireemu daemon for darwin-arm64",
   "homepage": "https://t-k.github.io/fireemu/",
   "repository": {