@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-module-host/src/host_ctx.rs

@@ -0,0 +1,382 @@
+//! The slice of the running app a module reaches through, and the blanket impl
+//! that lifts it to the `Arc` a router carries as its state.
+
+use std::any::{Any, TypeId};
+use std::path::Path;
+use std::sync::Arc;
+
+use axum::http::StatusCode;
+use axum::response::Response;
+
+use kroma_domain::metadata::{EpisodeInfo, MatchCandidate};
+use kroma_domain::{Audience, NotificationSpec, Permission, User};
+
+use super::{Contribution, Event, LibraryFolders};
+
+/// The slice of the running app a module's backend can reach. The binary's
+/// `AppState` (as `Arc<AppState>` = `SharedState`) implements it; a module crate
+/// names only this trait, never the app, so it stays a leaf and breaks the cycle.
+pub trait HostCtx: Send + Sync + 'static {
+    fn data_dir(&self) -> &Path;
+
+    // Resolve a session bearer token to the account holding it, or `None` for a
+    // missing, expired or unknown one. Blocking: in-process this is one indexed
+    // read, out-of-process it is the `/_host/session` callback.
+    fn session_user(&self, token: &str) -> Option<User>;
+
+    // A failure is a localized `403` response.
+    fn require(&self, user: &User, perm: Permission) -> Result<(), Response>;
+
+    // Gate on holding ANY management capability (unlocks the console shell).
+    fn require_any_admin(&self, user: &User) -> Result<(), Response>;
+
+    // A localized JSON error for `user`'s account locale, from a message `key`.
+    fn lerr(&self, user: &User, status: StatusCode, key: &str) -> Response;
+
+    fn setting_str(&self, key: &str, default: &str) -> String;
+    fn setting_bool(&self, key: &str, default: bool) -> bool;
+    fn setting_i64(&self, key: &str, default: i64) -> i64;
+    // Persist a batch of settings atomically (one write).
+    fn set_settings(&self, patch: std::collections::BTreeMap<String, serde_json::Value>);
+
+    fn publish(&self, event: Event);
+    // Publish an event addressed to ONE user. Required rather than defaulted: a
+    // host that forgot it would silently swallow every addressed event.
+    fn publish_to(&self, user_id: &str, event: Event);
+
+    // Raise a durable notification: it lands in the recipients' notification
+    // centre and, once they've subscribed a device, is pushed to them. Returns
+    // how many accounts were notified. A module supplies its own words through
+    // `NotificationSpec::custom`; the core resolves the audience and honours
+    // each recipient's per-category preferences.
+    fn notify(&self, audience: &Audience, spec: &NotificationSpec) -> usize;
+    // Trigger a background job by its key (e.g. `"acquisition.import"`). No-op if
+    // the key is unknown or already running.
+    fn trigger_job(&self, key: &'static str, reason: &'static str);
+
+    fn module_enabled(&self, id: &str) -> bool;
+
+    // Resolved core-side from the persisted `libraries` setting, falling back to
+    // the env-configured media dirs on first run. Empty when none configured.
+    fn library_folders(&self) -> Vec<LibraryFolders>;
+
+    // A credential the operator configured, by name (`"tmdb"`). `None` when that
+    // one is not set up.
+    //
+    // Named rather than one method per provider: the host contract must not grow
+    // a method every time something needs an API key, and a module asking for a
+    // vendor by name is a module naming its own dependency rather than the core
+    // naming it for everyone.
+    fn secret(&self, name: &str) -> Option<String>;
+
+    // The metadata language tag (e.g. `"fr-FR"`) for TMDB lookups.
+    fn metadata_language(&self) -> String;
+
+    // Provider titles matching `query`, ranked most-likely-first against
+    // `(query, year)` by the same scoring the automatic path uses. `kind` is
+    // `movie` | `show`. Empty when no provider is configured, so a caller
+    // degrades to "nothing matched" rather than failing.
+    fn metadata_candidates(&self, query: &str, kind: &str, year: Option<u32>)
+        -> Vec<MatchCandidate>;
+
+    // One season's episodes, as the provider names them. Best-effort: an empty
+    // list is "nothing to add", never an error.
+    fn metadata_episodes(&self, tmdb_id: u64, season: u32) -> Vec<EpisodeInfo>;
+
+    // Prefer the typed [`service`] helper.
+    fn get_service(&self, type_id: TypeId) -> Option<Arc<dyn Any + Send + Sync>>;
+
+    /// Every installed, enabled, running module contributing `point`. This is the
+    /// ONE hook the core offers for cross-module calls, and the reason it can
+    /// route between modules whose purpose it cannot name: `point` is a contract
+    /// name, never a module id, and the answer is a list because more than one
+    /// module may answer the same point.
+    ///
+    /// Resolved per call rather than cached, so a provider that was just
+    /// installed, restarted, or moved to another localhost port is picked up with
+    /// nothing re-wired.
+    fn contributions(&self, point: &str) -> Vec<Contribution>;
+}
+
+// The router state is `Arc<AppState>`, but the orphan rule forbids
+// `impl HostCtx for Arc<AppState>` in the app crate. This blanket impl - legal
+// here because the trait is local - lifts any `T: HostCtx` to `Arc<T>`.
+impl<T: HostCtx + ?Sized> HostCtx for std::sync::Arc<T> {
+    fn data_dir(&self) -> &Path {
+        (**self).data_dir()
+    }
+    fn session_user(&self, token: &str) -> Option<User> {
+        (**self).session_user(token)
+    }
+    fn require(&self, user: &User, perm: Permission) -> Result<(), Response> {
+        (**self).require(user, perm)
+    }
+    fn require_any_admin(&self, user: &User) -> Result<(), Response> {
+        (**self).require_any_admin(user)
+    }
+    fn lerr(&self, user: &User, status: StatusCode, key: &str) -> Response {
+        (**self).lerr(user, status, key)
+    }
+    fn setting_str(&self, key: &str, default: &str) -> String {
+        (**self).setting_str(key, default)
+    }
+    fn setting_bool(&self, key: &str, default: bool) -> bool {
+        (**self).setting_bool(key, default)
+    }
+    fn setting_i64(&self, key: &str, default: i64) -> i64 {
+        (**self).setting_i64(key, default)
+    }
+    fn set_settings(&self, patch: std::collections::BTreeMap<String, serde_json::Value>) {
+        (**self).set_settings(patch)
+    }
+    fn publish(&self, event: Event) {
+        (**self).publish(event)
+    }
+    fn publish_to(&self, user_id: &str, event: Event) {
+        (**self).publish_to(user_id, event)
+    }
+    fn notify(&self, audience: &Audience, spec: &NotificationSpec) -> usize {
+        (**self).notify(audience, spec)
+    }
+    fn trigger_job(&self, key: &'static str, reason: &'static str) {
+        (**self).trigger_job(key, reason)
+    }
+    fn module_enabled(&self, id: &str) -> bool {
+        (**self).module_enabled(id)
+    }
+    fn library_folders(&self) -> Vec<LibraryFolders> {
+        (**self).library_folders()
+    }
+    fn secret(&self, name: &str) -> Option<String> {
+        (**self).secret(name)
+    }
+    fn metadata_language(&self) -> String {
+        (**self).metadata_language()
+    }
+
+    fn metadata_candidates(
+        &self,
+        query: &str,
+        kind: &str,
+        year: Option<u32>,
+    ) -> Vec<MatchCandidate> {
+        (**self).metadata_candidates(query, kind, year)
+    }
+
+    fn metadata_episodes(&self, tmdb_id: u64, season: u32) -> Vec<EpisodeInfo> {
+        (**self).metadata_episodes(tmdb_id, season)
+    }
+    fn get_service(&self, type_id: TypeId) -> Option<Arc<dyn Any + Send + Sync>> {
+        (**self).get_service(type_id)
+    }
+    fn contributions(&self, point: &str) -> Vec<Contribution> {
+        (**self).contributions(point)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    use kroma_domain::NotificationEvent;
+
+    use crate::testing;
+
+    #[test]
+    fn the_arc_blanket_impl_forwards_the_addressed_methods() {
+        let host = Arc::new(testing::StubHost::new());
+        let via_arc: &dyn HostCtx = &host;
+
+        via_arc.publish_to(
+            "ana",
+            Event::new("notification.created", serde_json::json!({})),
+        );
+        let spec = NotificationSpec::new(
+            NotificationEvent::RequestApproved,
+            "notifications.request.approved.title",
+            "notifications.request.approved.body",
+        );
+        assert_eq!(via_arc.notify(&Audience::user("ana"), &spec), 1);
+
+        assert_eq!(
+            host.published(),
+            [(Some("ana".to_string()), "notification.created".to_string())]
+        );
+        assert_eq!(
+            host.notifications()
+                .iter()
+                .map(|(_, s)| s.event.as_str())
+                .collect::<Vec<_>>(),
+            ["request.approved"]
+        );
+    }
+
+    #[derive(Default)]
+    struct Recorder {
+        calls: std::sync::Mutex<Vec<String>>,
+    }
+
+    impl Recorder {
+        fn note(&self, what: &str) {
+            self.calls.lock().unwrap().push(what.to_string());
+        }
+        fn calls(&self) -> Vec<String> {
+            self.calls.lock().unwrap().clone()
+        }
+    }
+
+    impl HostCtx for Recorder {
+        fn data_dir(&self) -> &Path {
+            Path::new("/recorder")
+        }
+        fn session_user(&self, token: &str) -> Option<User> {
+            self.note(&format!("session_user:{token}"));
+            None
+        }
+        fn require(&self, _user: &User, _perm: Permission) -> Result<(), Response> {
+            self.note("require");
+            Ok(())
+        }
+        fn require_any_admin(&self, _user: &User) -> Result<(), Response> {
+            self.note("require_any_admin");
+            Ok(())
+        }
+        fn lerr(&self, _user: &User, _status: StatusCode, _key: &str) -> Response {
+            unimplemented!("not exercised")
+        }
+        fn setting_str(&self, key: &str, _default: &str) -> String {
+            self.note("setting_str");
+            format!("str:{key}")
+        }
+        fn setting_bool(&self, _key: &str, _default: bool) -> bool {
+            self.note("setting_bool");
+            true
+        }
+        fn setting_i64(&self, _key: &str, _default: i64) -> i64 {
+            self.note("setting_i64");
+            42
+        }
+        fn set_settings(&self, _patch: std::collections::BTreeMap<String, serde_json::Value>) {
+            self.note("set_settings");
+        }
+        fn publish(&self, _event: Event) {
+            self.note("publish");
+        }
+        fn publish_to(&self, user_id: &str, _event: Event) {
+            self.note(&format!("publish_to:{user_id}"));
+        }
+        fn notify(&self, _audience: &Audience, _spec: &NotificationSpec) -> usize {
+            self.note("notify");
+            7
+        }
+        fn trigger_job(&self, key: &'static str, _reason: &'static str) {
+            self.note(&format!("trigger_job:{key}"));
+        }
+        fn module_enabled(&self, _id: &str) -> bool {
+            self.note("module_enabled");
+            false
+        }
+        fn library_folders(&self) -> Vec<LibraryFolders> {
+            self.note("library_folders");
+            Vec::new()
+        }
+        fn secret(&self, name: &str) -> Option<String> {
+            self.note(&format!("secret:{name}"));
+            Some("key".into())
+        }
+        fn metadata_language(&self) -> String {
+            self.note("metadata_language");
+            "fr-FR".into()
+        }
+        fn metadata_candidates(
+            &self,
+            query: &str,
+            _kind: &str,
+            _year: Option<u32>,
+        ) -> Vec<MatchCandidate> {
+            self.note(&format!("metadata_candidates:{query}"));
+            Vec::new()
+        }
+        fn metadata_episodes(&self, tmdb_id: u64, season: u32) -> Vec<EpisodeInfo> {
+            self.note(&format!("metadata_episodes:{tmdb_id}:{season}"));
+            Vec::new()
+        }
+        fn contributions(&self, _point: &str) -> Vec<Contribution> {
+            Vec::new()
+        }
+        fn get_service(&self, _t: TypeId) -> Option<Arc<dyn Any + Send + Sync>> {
+            self.note("get_service");
+            None
+        }
+    }
+
+    #[test]
+    fn every_call_through_an_arc_reaches_the_host_inside_it() {
+        let inner = Arc::new(Recorder::default());
+        let host: Arc<Recorder> = inner.clone();
+
+        let user = User {
+            id: "u1".into(),
+            email: "u1@t.dev".into(),
+            username: "u1".into(),
+            avatar_url: None,
+            language: None,
+            audio_language: None,
+            subtitle_language: None,
+            permissions: Vec::new(),
+            created_at: "now".into(),
+            has_pin: false,
+        };
+
+        assert_eq!(host.data_dir(), Path::new("/recorder"));
+        assert!(host.session_user("tok").is_none());
+        host.require(&user, Permission::Playback).unwrap();
+        host.require_any_admin(&user).unwrap();
+        assert_eq!(host.setting_str("k", "d"), "str:k");
+        assert!(host.setting_bool("k", false));
+        assert_eq!(host.setting_i64("k", 0), 42);
+        host.set_settings(std::collections::BTreeMap::new());
+        host.publish(Event::new("t", json!({})));
+        host.publish_to("u1", Event::new("t", json!({})));
+        let spec = NotificationSpec::new(
+            NotificationEvent::RequestApproved,
+            "notifications.request.approved.title",
+            "notifications.request.approved.body",
+        );
+        assert_eq!(host.notify(&Audience::user("u1"), &spec), 7);
+        host.trigger_job("acquisition.search", "test");
+        assert!(!host.module_enabled("tv.kroma.indexer"));
+        assert!(host.library_folders().is_empty());
+        assert_eq!(host.secret("tmdb").as_deref(), Some("key"));
+        assert_eq!(host.metadata_language(), "fr-FR");
+        assert!(host.metadata_candidates("Dune", "movie", Some(2021)).is_empty());
+        assert!(host.metadata_episodes(1399, 2).is_empty());
+        assert!(host.get_service(TypeId::of::<u8>()).is_none());
+
+        assert_eq!(
+            inner.calls(),
+            [
+                "session_user:tok",
+                "require",
+                "require_any_admin",
+                "setting_str",
+                "setting_bool",
+                "setting_i64",
+                "set_settings",
+                "publish",
+                "publish_to:u1",
+                "notify",
+                "trigger_job:acquisition.search",
+                "module_enabled",
+                "library_folders",
+                "secret:tmdb",
+                "metadata_language",
+                "metadata_candidates:Dune",
+                "metadata_episodes:1399:2",
+                "get_service",
+            ]
+        );
+    }
+}

package/rust/kroma-module-host/src/host_token.rs

@@ -0,0 +1,147 @@
+//! The shared-host-token guard.
+//!
+//! Every hop of the module IPC authenticates with the SAME random token the
+//! supervisor mints at boot: the core's `/api/_host/*` callbacks, the core's
+//! `/_host/register-job` endpoint, and a sidecar's `/_job/run/*` + `/_port/*`
+//! routes. It lives in the host seam they all already depend on.
+
+use axum::extract::{Request, State};
+use axum::http::{HeaderMap, StatusCode};
+use axum::middleware::Next;
+use axum::response::{IntoResponse, Response};
+
+/// Middleware state for [`require_host_token`]: the shared host token. Pass it to
+/// `axum::middleware::from_fn_with_state` alongside [`require_host_token`].
+#[derive(Clone)]
+pub struct HostToken(pub String);
+
+/// Reject a request whose bearer does not match the shared host token.
+pub async fn require_host_token(
+    State(token): State<HostToken>,
+    headers: HeaderMap,
+    req: Request,
+    next: Next,
+) -> Response {
+    let ok = headers
+        .get(axum::http::header::AUTHORIZATION)
+        .and_then(|v| v.to_str().ok())
+        .and_then(|v| v.strip_prefix("Bearer "))
+        .is_some_and(|t| ct_eq(t.as_bytes(), token.0.as_bytes()));
+    if ok {
+        next.run(req).await
+    } else {
+        (StatusCode::UNAUTHORIZED, "bad host token").into_response()
+    }
+}
+
+// Constant-time, so matching the shared host token never leaks a shared
+// prefix through timing.
+fn ct_eq(a: &[u8], b: &[u8]) -> bool {
+    if a.len() != b.len() {
+        return false;
+    }
+    let mut diff = 0u8;
+    for (x, y) in a.iter().zip(b) {
+        diff |= x ^ y;
+    }
+    diff == 0
+}
+
+#[cfg(test)]
+mod tests {
+    use axum::body::Body;
+    use axum::middleware::from_fn_with_state;
+    use axum::routing::get;
+    use axum::Router;
+    use tower::ServiceExt as _;
+
+    use super::*;
+
+    const TOKEN: &str = "s3cret-host-token";
+
+    fn guarded() -> Router {
+        Router::new()
+            .route("/_host/ping", get(|| async { "pong" }))
+            .layer(from_fn_with_state(
+                HostToken(TOKEN.to_string()),
+                require_host_token,
+            ))
+    }
+
+    async fn call(auth: Option<&str>) -> StatusCode {
+        let mut builder = Request::builder().uri("/_host/ping");
+        if let Some(v) = auth {
+            builder = builder.header(axum::http::header::AUTHORIZATION, v);
+        }
+        guarded()
+            .oneshot(builder.body(Body::empty()).unwrap())
+            .await
+            .unwrap()
+            .status()
+    }
+
+    #[tokio::test]
+    async fn the_shared_token_is_let_through() {
+        assert_eq!(call(Some(&format!("Bearer {TOKEN}"))).await, StatusCode::OK);
+    }
+
+    #[tokio::test]
+    async fn everything_else_is_rejected() {
+        assert_eq!(
+            call(None).await,
+            StatusCode::UNAUTHORIZED,
+            "no header at all"
+        );
+        assert_eq!(
+            call(Some("")).await,
+            StatusCode::UNAUTHORIZED,
+            "empty header"
+        );
+        assert_eq!(
+            call(Some(TOKEN)).await,
+            StatusCode::UNAUTHORIZED,
+            "no Bearer scheme"
+        );
+        assert_eq!(
+            call(Some(&format!("bearer {TOKEN}"))).await,
+            StatusCode::UNAUTHORIZED,
+            "the scheme is case-sensitive here, unlike the user-facing one",
+        );
+        assert_eq!(
+            call(Some(&format!("Basic {TOKEN}"))).await,
+            StatusCode::UNAUTHORIZED,
+            "a different scheme",
+        );
+        assert_eq!(
+            call(Some("Bearer ")).await,
+            StatusCode::UNAUTHORIZED,
+            "empty token"
+        );
+    }
+
+    #[tokio::test]
+    async fn a_token_that_merely_starts_right_is_rejected() {
+        assert_eq!(call(Some("Bearer s3cret")).await, StatusCode::UNAUTHORIZED);
+        assert_eq!(
+            call(Some(&format!("Bearer {TOKEN}-extra"))).await,
+            StatusCode::UNAUTHORIZED
+        );
+        assert_eq!(
+            call(Some(&format!("Bearer {}", &TOKEN[..TOKEN.len() - 1]))).await,
+            StatusCode::UNAUTHORIZED
+        );
+    }
+
+    #[test]
+    fn the_comparison_is_length_checked_then_constant_time() {
+        assert!(ct_eq(b"", b""));
+        assert!(ct_eq(b"abc", b"abc"));
+        assert!(!ct_eq(b"abc", b"abd"), "last byte differs");
+        assert!(!ct_eq(b"abc", b"xbc"), "first byte differs");
+        assert!(!ct_eq(b"abc", b"ab"), "shorter");
+        assert!(!ct_eq(b"ab", b"abc"), "longer");
+        // Non-UTF8 bytes compare the same way; the token is bytes, not text.
+        assert!(ct_eq(&[0xff, 0x00, 0x7f], &[0xff, 0x00, 0x7f]));
+        assert!(!ct_eq(&[0xff, 0x00], &[0xff, 0x01]));
+    }
+}

package/rust/kroma-module-host/src/lib.rs

@@ -0,0 +1,141 @@
+//! The host seam between the running app and a module's backend: a module crate
+//! names only the [`HostCtx`] trait here, never `kroma-engine`, so the two do not
+//! form a dependency cycle.
+
+// The axum `Response` is deliberately the Err type of request guards so handlers
+// short-circuit with `?`.
+#![allow(clippy::result_large_err)]
+
+pub mod host_token;
+
+/// The `storage` capability: the module-private and scoped-core databases. Off
+/// unless the module declares storage, which is what keeps SQLite out of the
+/// eight sidecars that never open one.
+#[cfg(feature = "storage")]
+pub mod storage;
+
+#[cfg(any(test, feature = "testing"))]
+pub mod testing;
+
+/// [`test_serve::serve`] and [`test_serve::blocking`]: the wire-level helpers a
+/// point contract's round-trip test needs, without the database `testing` drags in.
+#[cfg(any(test, feature = "test-serve"))]
+pub mod test_serve;
+
+mod auth;
+mod host_ctx;
+mod module;
+mod port;
+
+pub use auth::*;
+pub use host_ctx::*;
+pub use module::*;
+pub use port::*;
+
+use axum::http::StatusCode;
+use axum::response::{IntoResponse, Response};
+use axum::Json;
+
+pub use async_trait::async_trait;
+pub use kroma_domain::{
+    ActionKind, ActionSpec, ActionStyle, Audience, NotificationCategory, NotificationEvent,
+    NotificationSpec, PushCategory,
+};
+
+/// Build a JSON error response `{ "error": "<message>" }` with the given status.
+pub fn json_error(status: StatusCode, message: &str) -> Response {
+    (status, Json(serde_json::json!({ "error": message }))).into_response()
+}
+
+/// Run a blocking DB closure off the async runtime, mapping any failure to a
+/// uniform 500.
+pub async fn blocking<T, F>(f: F) -> Result<T, Response>
+where
+    F: FnOnce() -> anyhow::Result<T> + Send + 'static,
+    T: Send + 'static,
+{
+    match tokio::task::spawn_blocking(f).await {
+        Ok(Ok(v)) => Ok(v),
+        Ok(Err(e)) => {
+            tracing::error!(error = %e, "database error");
+            Err(json_error(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "internal error",
+            ))
+        }
+        Err(e) => {
+            tracing::error!(error = %e, "task join error");
+            Err(json_error(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "internal error",
+            ))
+        }
+    }
+}
+
+#[cfg(feature = "storage")]
+pub use storage::{query, HostStorage};
+
+/// A real-time event a module publishes onto the host's bus, fanned out to
+/// WebSocket clients as `{ "type": <topic>, ...payload }`.
+pub struct Event {
+    pub topic: String,
+    pub payload: serde_json::Value,
+}
+
+impl Event {
+    pub fn new(topic: impl Into<String>, payload: serde_json::Value) -> Self {
+        Self {
+            topic: topic.into(),
+            payload,
+        }
+    }
+}
+
+/// One configured library, in the leaf shape a module needs to place files.
+/// `kind` is `movies` or `shows`.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct LibraryFolders {
+    pub id: String,
+    pub kind: String,
+    pub name: String,
+    pub folders: Vec<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn json_error_carries_the_status() {
+        let resp = json_error(StatusCode::NOT_FOUND, "gone");
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+        let resp = json_error(StatusCode::FORBIDDEN, "no");
+        assert_eq!(resp.status(), StatusCode::FORBIDDEN);
+    }
+
+    #[test]
+    fn event_new_keeps_topic_and_payload() {
+        let ev = Event::new("download.progress", serde_json::json!({ "pct": 42 }));
+        assert_eq!(ev.topic, "download.progress");
+        assert_eq!(ev.payload["pct"], 42);
+    }
+
+    #[tokio::test]
+    async fn blocking_returns_value_and_maps_failure_to_500() {
+        let ok: Result<i32, Response> = blocking(|| Ok(21 * 2)).await;
+        assert_eq!(ok.unwrap(), 42);
+
+        let err = blocking::<i32, _>(|| Err(anyhow::anyhow!("db down"))).await;
+        assert_eq!(err.unwrap_err().status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+
+    #[tokio::test]
+    async fn a_panicking_blocking_task_becomes_a_500_rather_than_taking_the_server_down() {
+        let panicked = blocking::<i32, _>(|| panic!("a module's closure panicked")).await;
+        assert_eq!(
+            panicked.unwrap_err().status(),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+    }
+}