@nmtjs/proxy 0.15.0-beta.3 → 0.15.0-beta.31

package/src/server.rs

@@ -0,0 +1,80 @@
+use std::{collections::HashMap, sync::Arc};
+
+use tokio::{sync::Mutex, task::JoinHandle};
+use tokio_util::sync::CancellationToken;
+
+#[allow(dead_code)]
+#[derive(Clone)]
+pub struct Server {
+    services: Arc<Mutex<HashMap<String, ServiceHandle>>>,
+}
+
+#[allow(dead_code)]
+pub struct ServiceHandle {
+    pub cancel: CancellationToken,
+    pub task: JoinHandle<()>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum AddServiceError {
+    AlreadyExists,
+}
+
+impl Server {
+    pub fn new() -> Self {
+        Self {
+            services: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub async fn add_service(
+        &self,
+        name: String,
+        service: ServiceHandle,
+    ) -> Result<(), AddServiceError> {
+        let mut guard = self.services.lock().await;
+        if guard.contains_key(&name) {
+            return Err(AddServiceError::AlreadyExists);
+        }
+        guard.insert(name, service);
+        Ok(())
+    }
+
+    pub async fn upsert_service(&self, name: String, service: ServiceHandle) {
+        let old = {
+            let mut guard = self.services.lock().await;
+            guard.insert(name, service)
+        };
+
+        if let Some(old) = old {
+            old.cancel.cancel();
+            let _ = old.task.await;
+        }
+    }
+
+    pub async fn remove_service(&self, name: &str) {
+        let old = {
+            let mut guard = self.services.lock().await;
+            guard.remove(name)
+        };
+
+        if let Some(old) = old {
+            old.cancel.cancel();
+            let _ = old.task.await;
+        }
+    }
+
+    pub async fn stop_all(&self) {
+        let services = {
+            let mut guard = self.services.lock().await;
+            std::mem::take(&mut *guard)
+        };
+
+        for (_, handle) in services {
+            handle.cancel.cancel();
+            let _ = handle.task.await;
+        }
+    }
+}

package/src/config.rs

@@ -1,199 +0,0 @@
-use napi::bindgen_prelude::*;
-use napi_derive::napi;
-use std::{collections::HashMap, time::Duration};
-use url::Url;
-
-#[napi(object)]
-pub struct ApplicationUpstreamConfig {
-    pub url: String,
-    #[napi(ts_type = "'http' | 'websocket'")]
-    pub r#type: String,
-}
-
-#[napi(object)]
-pub struct ApplicationConfig {
-    pub upstreams: Vec<ApplicationUpstreamConfig>,
-    pub sni: Option<String>,
-    pub enable_tls: Option<bool>,
-}
-
-#[napi(object)]
-pub struct ProxyOptions {
-    pub listen: Option<String>,
-    pub tls: Option<bool>,
-    pub threads: Option<u16>,
-    pub health_check_interval: Option<u32>,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub enum UpstreamKind {
-    Http,
-    Websocket,
-}
-
-impl UpstreamKind {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            Self::Http => "http",
-            Self::Websocket => "websocket",
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum AppUpstream {
-    Port {
-        secure: bool,
-        #[allow(dead_code)]
-        address: String,
-        port: u16,
-        hostname: String,
-    },
-    Unix {
-        secure: bool,
-        path: String,
-    },
-}
-
-pub struct AppDefinition {
-    pub upstreams: HashMap<UpstreamKind, Vec<AppUpstream>>,
-    pub sni: Option<String>,
-}
-
-pub struct ProxyConfig {
-    pub apps: HashMap<String, AppDefinition>,
-    pub listen: Option<String>,
-    pub threads: Option<u16>,
-    pub tls: bool,
-    pub health_check_interval: Option<Duration>,
-}
-
-impl ProxyConfig {
-    pub fn from_inputs(
-        apps: HashMap<String, ApplicationConfig>,
-        options: Option<ProxyOptions>,
-    ) -> Result<Self> {
-        if apps.is_empty() {
-            return Err(Error::from_reason(
-                "apps map must contain at least one application",
-            ));
-        }
-
-        let mut normalized_apps = HashMap::with_capacity(apps.len());
-        for (name, config) in apps {
-            if config.upstreams.is_empty() {
-                return Err(Error::from_reason(format!(
-                    "application '{name}' must provide at least one upstream"
-                )));
-            }
-
-            let mut upstreams = HashMap::new();
-
-            for upstream in config.upstreams {
-                let trimmed = upstream.url.trim().to_string();
-                if trimmed.is_empty() {
-                    return Err(Error::from_reason(format!(
-                        "upstream URL cannot be empty in application '{name}'"
-                    )));
-                }
-
-                let parsed = Url::parse(&trimmed).map_err(|_| {
-                    Error::from_reason(format!(
-                        "invalid URL '{trimmed}' in upstreams for application '{name}'"
-                    ))
-                })?;
-
-                let secure = match parsed.scheme() {
-                    "https" | "wss" | "https+unix" | "wss+unix" => true,
-                    "http" | "ws" | "http+unix" | "ws+unix" => false,
-                    other => {
-                        return Err(Error::from_reason(format!(
-                            "unsupported URL scheme '{other}' in upstream '{trimmed}'"
-                        )));
-                    }
-                };
-
-                let upstream_type = match upstream.r#type.as_str() {
-                    "http" => UpstreamKind::Http,
-                    "websocket" => UpstreamKind::Websocket,
-                    other => {
-                        return Err(Error::from_reason(format!(
-                            "unsupported upstream type '{other}' for application '{name}'"
-                        )));
-                    }
-                };
-
-                let upstream = if parsed.scheme().ends_with("+unix") {
-                    AppUpstream::Unix {
-                        secure,
-                        path: parsed.path().to_string(),
-                    }
-                } else {
-                    let host = parsed.host_str().ok_or_else(|| {
-                        Error::from_reason(format!(
-                            "missing host in upstream URL '{trimmed}' for application '{name}'"
-                        ))
-                    })?;
-                    let port = parsed.port_or_known_default().ok_or_else(|| {
-                        Error::from_reason(format!(
-                            "missing port in upstream URL '{trimmed}' for application '{name}'"
-                        ))
-                    })?;
-                    AppUpstream::Port {
-                        secure,
-                        address: parsed.to_string(),
-                        port,
-                        hostname: host.to_string(),
-                    }
-                };
-
-                upstreams
-                    .entry(upstream_type)
-                    .or_insert_with(Vec::new)
-                    .push(upstream);
-            }
-
-            if upstreams.is_empty() {
-                return Err(Error::from_reason(format!(
-                    "application '{name}' produced no valid upstreams"
-                )));
-            }
-
-            let definition = AppDefinition {
-                upstreams,
-                sni: config.sni.filter(|value| !value.is_empty()),
-            };
-
-            normalized_apps.insert(name, definition);
-        }
-
-        let options = options.unwrap_or_default();
-
-        let health_check_interval = options
-            .health_check_interval
-            .map(|secs| Duration::from_secs(secs as u64));
-
-        Ok(Self {
-            apps: normalized_apps,
-            listen: options.listen,
-            threads: options.threads,
-            tls: options.tls.unwrap_or(false),
-            health_check_interval,
-        })
-    }
-
-    pub fn listener(&self) -> &str {
-        self.listen.as_deref().unwrap_or("0.0.0.0:6188")
-    }
-}
-
-impl Default for ProxyOptions {
-    fn default() -> Self {
-        Self {
-            listen: None,
-            threads: None,
-            tls: None,
-            health_check_interval: Some(30),
-        }
-    }
-}