API Routes for Modules

server/Cargo.toml

@@ -70,7 +70,7 @@ reqwest = { version = "0.11.18", default_features = false, features = [
 ] }
 rustls = "0.20"
 rustls-pemfile = "1.0"
-semver = "1.0"
+semver = { version = "1.0", features = ["serde"] }
 serde = { version = "1.0", features = ["rc"] }
 serde_json = "1.0"
 static-files = "0.2"

server/src/external_service.rs

@@ -0,0 +1,104 @@
+use std::{
+    collections::HashMap,
+    sync::{Arc, RwLock},
+};
+
+use once_cell::sync::Lazy;
+use semver::Version;
+
+pub static MODULE_REGISTRY: Lazy<Arc<RwLock<ModuleRegistry>>> = Lazy::new(Arc::default);
+
+#[derive(Debug, Default)]
+pub struct ModuleRegistry {
+    inner: HashMap<String, Registration>,
+}
+
+impl ModuleRegistry {
+    pub fn register(&mut self, module: Registration) {
+        self.inner.insert(module.id.clone(), module);
+    }
+
+    pub fn registrations(&self) -> impl Iterator<Item = &Registration> {
+        self.inner.values()
+    }
+
+    pub fn get(&self, id: &str) -> Option<&Registration> {
+        self.inner.get(id)
+    }
+    pub fn deregister(&mut self, module_id: &str) {
+        self.inner.remove(module_id);
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
+pub struct StreamConfig {
+    pub path: String,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
+#[serde(rename_all = "camelCase")]
+pub struct Registration {
+    pub id: String,
+    pub version: String,
+    pub url: url::Url,
+    pub username: String,
+    pub password: String,
+    pub stream_config: StreamConfig,
+    pub routes: Vec<Route>,
+}
+
+impl Registration {
+    pub fn get_module_path(&self, path: &str, method: &http::Method) -> Option<String> {
+        self.routes
+            .iter()
+            .find(|x| x.server_path == path && method.eq(&x.method))
+            .map(|route| route.module_path.clone())
+    }
+
+    pub fn set_version(&mut self, version: &str) -> Result<(), String> {
+        if let Some(version) = version.strip_prefix('v') {
+            if Version::parse(version).is_err() {
+                return Err("Invalid SemVer format".to_string());
+            }
+            self.version = version.to_string();
+            Ok(())
+        } else {
+            Err("Module version must start with 'v'".to_string())
+        }
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
+pub struct DeRegistration {
+    pub id: String,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
+#[serde(rename_all = "camelCase")]
+pub struct Route {
+    pub server_path: String,
+    pub module_path: String,
+    pub method: Method,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
+#[serde(rename_all = "UPPERCASE")]
+#[allow(clippy::upper_case_acronyms)]
+pub enum Method {
+    GET,
+    PUT,
+    POST,
+    DELETE,
+}
+
+impl PartialEq<Method> for http::Method {
+    fn eq(&self, other: &Method) -> bool {
+        matches!(
+            (self, other),
+            (&http::Method::GET, &Method::GET)
+                | (&http::Method::PUT, &Method::PUT)
+                | (&http::Method::POST, &Method::POST)
+                | (&http::Method::DELETE, &Method::DELETE)
+        )
+    }
+}

server/src/handlers/http.rs

@@ -32,12 +32,13 @@ use openid::Discovered;
 use rustls::{Certificate, PrivateKey, ServerConfig};
 use rustls_pemfile::{certs, pkcs8_private_keys};
 
-use crate::option::CONFIG;
 use crate::rbac::role::Action;
+use crate::{external_service::MODULE_REGISTRY, option::CONFIG};
 
 use self::middleware::{DisAllowRootUser, RouteExt};
 
 mod about;
+mod external;
 mod health_check;
 mod ingest;
 mod llm;
@@ -286,6 +287,21 @@ pub fn configure_routes(
         oauth_api = oauth_api.app_data(web::Data::from(client))
     }
 
+    let external_services = web::scope("modules")
+        .service(resource("").route(web::get().to(external::get)))
+        .service(
+            resource("/register")
+                .route(web::put().to(external::register))
+                .route(web::delete().to(external::deregister)),
+        )
+        .service(
+            resource("{module}/config/{logstream}")
+                .route(web::get().to(external::get_config))
+                .route(web::put().to(external::put_config)),
+        )
+        .service(resource("{module}/{tail}*").to(external::router))
+        .app_data(web::Data::from(Arc::clone(&*MODULE_REGISTRY)));
+
     // Deny request if username is same as the env variable P_USERNAME.
     cfg.service(
         // Base path "{url}/api/v1"
@@ -329,6 +345,7 @@ pub fn configure_routes(
             .service(user_api)
             .service(llm_query_api)
             .service(oauth_api)
+            .service(external_services)
             .service(role_api),
     )
     // GET "/" ==> Serve the static frontend directory