@assetsart/nylon-mesh 1.0.1

package/scripts/release.mjs

@@ -0,0 +1,52 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { join } from 'path';
+
+// Get version from standard arguments
+const newVersion = process.argv[2];
+
+if (!newVersion) {
+  console.error("❌ Please specify a version. Example: bun run release 1.0.0");
+  process.exit(1);
+}
+
+// Clean and validate semantic version tag
+const cleanVersion = newVersion.replace(/^v/, '');
+
+if (!/^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/.test(cleanVersion)) {
+  console.error(`❌ Invalid semantic version: ${newVersion}`);
+  process.exit(1);
+}
+
+const tagVersion = `v${cleanVersion}`;
+
+console.log(`📦 Bumping version to: ${cleanVersion} (Tag: ${tagVersion})`);
+
+try {
+  // Update package.json
+  console.log("📝 Updating package.json...");
+  const pkgPath = join(process.cwd(), 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  pkg.version = cleanVersion;
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+
+  // Update Cargo.toml
+  console.log("📝 Updating Cargo.toml...");
+  const processCargoPath = join(process.cwd(), 'Cargo.toml');
+  let cargoToml = readFileSync(processCargoPath, 'utf8');
+  cargoToml = cargoToml.replace(/^version\s*=\s*"[^"]+"/m, `version = "${cleanVersion}"`);
+  writeFileSync(processCargoPath, cargoToml);
+
+  // Run Git Commands
+  console.log("🔖 Creating git commit and tag...");
+  execSync('git add package.json Cargo.toml', { stdio: 'inherit' });
+  execSync(`git commit -m "chore: release ${tagVersion}"`, { stdio: 'inherit' });
+  execSync(`git tag ${tagVersion}`, { stdio: 'inherit' });
+
+  console.log("\n✅ Release prepared successfully!");
+  console.log(`\n🚀 To push the release, run:\n   git push origin main && git push origin ${tagVersion}`);
+
+} catch (err) {
+  console.error("\n❌ Error during release:", err.message);
+  process.exit(1);
+}

package/src/config.rs

@@ -0,0 +1,91 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Config {
+    pub threads: Option<usize>,
+    pub grace_period_seconds: Option<u64>,
+    pub graceful_shutdown_timeout_seconds: Option<u64>,
+    pub liveness_path: Option<String>,
+    pub readiness_path: Option<String>,
+    pub load_balancer_algo: Option<LoadBalancerAlgorithm>,
+    pub listen: Option<String>,
+    pub tls: Option<TlsConfig>,
+    pub upstreams: Vec<UpstreamConfig>,
+    pub redis_url: Option<String>,
+    pub cache: Option<CacheConfig>,
+    pub bypass: Option<BypassConfig>,
+    pub cache_control: Option<Vec<CacheControlConfig>>,
+}
+
+#[derive(Debug, Deserialize, Clone, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum LoadBalancerAlgorithm {
+    RoundRobin,
+    Random,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+#[serde(untagged)]
+pub enum UpstreamConfig {
+    Simple(String),
+    Weighted { address: String, weight: usize },
+}
+
+impl UpstreamConfig {
+    pub fn address(&self) -> &str {
+        match self {
+            Self::Simple(addr) => addr,
+            Self::Weighted { address, .. } => address,
+        }
+    }
+
+    pub fn weight(&self) -> usize {
+        match self {
+            Self::Simple(_) => 1,
+            Self::Weighted { weight, .. } => *weight,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct TlsConfig {
+    pub listen: String,
+    pub certs: Vec<CertificateConfig>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct CertificateConfig {
+    pub host: String, // e.g., "*.example.com" or "example.com" or "default"
+    pub cert_path: String,
+    pub key_path: String,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct CacheConfig {
+    pub tier1_capacity: Option<u64>,
+    pub tier1_ttl_seconds: Option<u64>,
+    pub tier2_ttl_seconds: Option<u64>,
+    pub status: Option<Vec<u16>>,
+    pub content_types: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct BypassConfig {
+    pub paths: Option<Vec<String>>,
+    pub extensions: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct CacheControlConfig {
+    pub value: String,
+    pub paths: Option<Vec<String>>,
+    pub extensions: Option<Vec<String>>,
+}
+
+impl Config {
+    pub fn load(path: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        let f = std::fs::File::open(path)?;
+        let config: Config = serde_yaml::from_reader(f)?;
+        Ok(config)
+    }
+}

package/src/main.rs

@@ -0,0 +1,214 @@
+#[cfg(not(debug_assertions))]
+use mimalloc::MiMalloc;
+
+#[cfg(not(debug_assertions))]
+#[global_allocator]
+static GLOBAL: MiMalloc = MiMalloc;
+
+pub mod config;
+pub mod proxy;
+pub mod tls_accept;
+
+use pingora_core::server::Server;
+use pingora_core::server::configuration::{Opt, ServerConf};
+use pingora_load_balancing::LoadBalancer;
+use pingora_proxy::http_proxy_service;
+use std::env;
+use std::sync::Arc;
+use tracing::{error, info};
+
+use config::Config;
+use proxy::MeshProxy;
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use tokio::signal;
+
+pub static IS_SHUTTING_DOWN: AtomicBool = AtomicBool::new(false);
+
+pub fn is_shutting_down() -> bool {
+    IS_SHUTTING_DOWN.load(Ordering::SeqCst)
+}
+
+// SIGTERM
+async fn try_shutdown() -> std::io::Result<()> {
+    #[cfg(unix)]
+    if let Ok(mut stream) = signal::unix::signal(signal::unix::SignalKind::terminate()) {
+        stream.recv().await;
+    }
+    Ok(())
+}
+
+async fn shutdown(shutdown_timeout: u64) {
+    println!("\n🛑 Shutting down...");
+    IS_SHUTTING_DOWN.store(true, Ordering::SeqCst);
+    // countdown
+    for i in (0..shutdown_timeout).rev() {
+        println!("Shutting down in {} seconds", i);
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    }
+}
+
+fn main() {
+    tracing_subscriber::fmt().init();
+
+    let args: Vec<String> = env::args().collect();
+    let config_path = if args.len() > 1 {
+        &args[1]
+    } else {
+        "nylon-mesh.yaml"
+    };
+
+    info!("Loading config from: {}", config_path);
+    let config = match Config::load(config_path) {
+        Ok(c) => Arc::new(c),
+        Err(e) => {
+            error!("Failed to load config: {}", e);
+            std::process::exit(1);
+        }
+    };
+
+    let mut pingora_upstreams = Vec::new();
+    for u in config.upstreams.iter() {
+        match pingora_load_balancing::Backend::new_with_weight(u.address(), u.weight()) {
+            Ok(b) => pingora_upstreams.push(b),
+            Err(e) => error!("Failed to parse upstream {}: {}", u.address(), e),
+        }
+    }
+
+    if pingora_upstreams.is_empty() {
+        error!("No upstreams configured in YAML.");
+        std::process::exit(1);
+    }
+
+    // Prepare discovery and backend manager
+    let discovery = pingora_load_balancing::discovery::Static::new(
+        pingora_upstreams
+            .into_iter()
+            .collect::<std::collections::BTreeSet<_>>(),
+    );
+    let backends = pingora_load_balancing::Backends::new(discovery);
+
+    // print!("config: {:?}", config);
+    let load_balancer = match config
+        .load_balancer_algo
+        .as_ref()
+        .unwrap_or(&crate::config::LoadBalancerAlgorithm::RoundRobin)
+    {
+        crate::config::LoadBalancerAlgorithm::RoundRobin => {
+            let lb = LoadBalancer::<pingora_load_balancing::selection::RoundRobin>::from_backends(
+                backends,
+            );
+            let rt = tokio::runtime::Runtime::new().unwrap();
+            rt.block_on(lb.update()).unwrap();
+            proxy::MeshLoadBalancer::RoundRobin(Arc::new(lb))
+        }
+        crate::config::LoadBalancerAlgorithm::Random => {
+            let lb =
+                LoadBalancer::<pingora_load_balancing::selection::Random>::from_backends(backends);
+            let rt = tokio::runtime::Runtime::new().unwrap();
+            rt.block_on(lb.update()).unwrap();
+            proxy::MeshLoadBalancer::Random(Arc::new(lb))
+        }
+    };
+
+    let tier1_capacity = config
+        .cache
+        .as_ref()
+        .and_then(|c| c.tier1_capacity)
+        .unwrap_or(10000);
+    let tier1_ttl = config
+        .cache
+        .as_ref()
+        .and_then(|c| c.tier1_ttl_seconds)
+        .unwrap_or(3);
+    let tier1_cache = moka::future::Cache::builder()
+        .max_capacity(tier1_capacity as u64)
+        .time_to_live(std::time::Duration::from_secs(tier1_ttl as u64))
+        .build();
+
+    let mut encoding_hits = std::collections::HashMap::new();
+    encoding_hits.insert("zstd", std::sync::atomic::AtomicU64::new(0));
+    encoding_hits.insert("br", std::sync::atomic::AtomicU64::new(0));
+    encoding_hits.insert("gzip", std::sync::atomic::AtomicU64::new(0));
+    encoding_hits.insert("deflate", std::sync::atomic::AtomicU64::new(0));
+
+    let proxy = MeshProxy {
+        config: config.clone(),
+        load_balancer: Arc::new(load_balancer),
+        tier1_cache,
+        encoding_hits: Arc::new(encoding_hits),
+    };
+
+    let opt = Opt::parse_args();
+    let mut server = Server::new(Some(opt)).unwrap_or_else(|e| {
+        error!("Failed to initialize Pingora Server: {}", e);
+        std::process::exit(1);
+    });
+
+    let threads = config.threads.unwrap_or_else(|| {
+        std::thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(1)
+    });
+
+    let grace_period_seconds = config.grace_period_seconds.unwrap_or(0);
+    let graceful_shutdown_timeout_seconds = config.graceful_shutdown_timeout_seconds.unwrap_or(0);
+
+    server.configuration = Arc::new(ServerConf {
+        daemon: false,
+        grace_period_seconds: Some(grace_period_seconds),
+        graceful_shutdown_timeout_seconds: Some(graceful_shutdown_timeout_seconds),
+        threads,
+        ..Default::default()
+    });
+    server.bootstrap();
+
+    let mut proxy_service = http_proxy_service(&server.configuration, proxy);
+
+    // Setup Listeners
+    if let Some(listen_addr) = &config.listen {
+        info!("Adding plain HTTP listener on {}", listen_addr);
+        proxy_service.add_tcp(listen_addr);
+    }
+
+    if let Some(tls) = &config.tls {
+        info!("Adding TLS listener on {}", tls.listen);
+        match tls_accept::new_tls_settings(tls.certs.clone()) {
+            Ok(settings) => {
+                proxy_service.add_tls_with_settings(&tls.listen, None, settings);
+            }
+            Err(e) => {
+                error!("Failed to create TLS settings: {:?}", e);
+                std::process::exit(1);
+            }
+        }
+    }
+
+    server.add_service(proxy_service);
+
+    let shutdown_timeout = config.graceful_shutdown_timeout_seconds.unwrap_or(0);
+    std::thread::spawn(move || {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+
+        rt.block_on(async move {
+            // Wait for shutdown signal
+            tokio::select! {
+                _ = signal::ctrl_c() => {
+                    println!("From ctrl_c");
+                    shutdown(shutdown_timeout).await;
+                },
+                _ = try_shutdown() => {
+                    println!("From try_shutdown");
+                    shutdown(shutdown_timeout).await;
+                },
+            }
+            println!("✅ Shutdown complete");
+        });
+    });
+
+    info!("Starting nylon-mesh proxy server...");
+    server.run_forever();
+}

package/src/proxy/cache.rs

@@ -0,0 +1,304 @@
+use bytes::Bytes;
+use http::StatusCode;
+use pingora::Result;
+use pingora::http::ResponseHeader;
+use pingora_proxy::Session;
+use serde::{Deserialize, Serialize};
+use tracing::{debug, error};
+
+use super::{MeshProxy, ProxyCtx};
+
+static REDIS_CONN: tokio::sync::OnceCell<redis::aio::MultiplexedConnection> =
+    tokio::sync::OnceCell::const_new();
+
+pub async fn get_redis_conn(redis_url: &str) -> Option<redis::aio::MultiplexedConnection> {
+    if redis_url.is_empty() {
+        return None;
+    }
+    match REDIS_CONN
+        .get_or_try_init(|| async {
+            let client =
+                redis::Client::open(redis_url).map_err(|e| format!("URL {}: {}", redis_url, e))?;
+            client
+                .get_multiplexed_async_connection()
+                .await
+                .map_err(|e| e.to_string())
+        })
+        .await
+    {
+        Ok(c) => Some(c.clone()),
+        Err(e) => {
+            error!("Failed to init Redis: {}", e);
+            None
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct CachedHeaders {
+    pub status: u16,
+    pub headers: Vec<(String, String)>,
+    #[serde(default)]
+    pub expires_at: u64,
+}
+
+impl MeshProxy {
+    pub fn determine_encodings_to_check(&self, accept_encoding: &str) -> Vec<&'static str> {
+        let mut check = Vec::new();
+        if accept_encoding.contains("gzip") {
+            check.push("gzip");
+        }
+        if accept_encoding.contains("zstd") {
+            check.push("zstd");
+        }
+        if accept_encoding.contains("br") {
+            check.push("br");
+        }
+        if accept_encoding.contains("deflate") {
+            check.push("deflate");
+        }
+        check.push(""); // Fallback
+
+        check.sort_by(|a, b| {
+            let hit_a = self
+                .encoding_hits
+                .get(a)
+                .map(|v| v.load(std::sync::atomic::Ordering::Relaxed))
+                .unwrap_or(0);
+            let hit_b = self
+                .encoding_hits
+                .get(b)
+                .map(|v| v.load(std::sync::atomic::Ordering::Relaxed))
+                .unwrap_or(0);
+            hit_b.cmp(&hit_a) // Descending
+        });
+        check
+    }
+
+    pub async fn fetch_from_redis(
+        &self,
+        session: &mut Session,
+        enc: &str,
+        host: &str,
+        cache_key: &str,
+        redis_url: &str,
+        now_secs: u64,
+    ) -> Result<bool> {
+        if let Some(mut conn) = get_redis_conn(redis_url).await {
+            let sub_key = cache_key.strip_prefix(host).unwrap_or(cache_key);
+            let headers_key = format!("{}:headers", sub_key);
+
+            let mut pipe = redis::pipe();
+            pipe.cmd("HGET")
+                .arg(host)
+                .arg(sub_key)
+                .cmd("HGET")
+                .arg(host)
+                .arg(&headers_key);
+
+            let query_result: redis::RedisResult<(Option<Vec<u8>>, Option<Vec<u8>>)> =
+                pipe.query_async(&mut conn).await;
+
+            if let Ok((Some(cached_payload), cached_headers_vec)) = query_result {
+                let mut status_code = StatusCode::OK;
+                let mut parsed_headers = Vec::new();
+                let mut is_new_format = false;
+
+                if let Some(headers_bytes) = cached_headers_vec {
+                    if let Ok(headers_json) = String::from_utf8(headers_bytes) {
+                        if let Ok(ch) = serde_json::from_str::<CachedHeaders>(&headers_json) {
+                            if ch.expires_at > 0 && now_secs > ch.expires_at {
+                                let mut del_pipe = redis::pipe();
+                                del_pipe
+                                    .cmd("HDEL")
+                                    .arg(host)
+                                    .arg(sub_key)
+                                    .cmd("HDEL")
+                                    .arg(host)
+                                    .arg(&headers_key);
+                                let _: redis::RedisResult<()> =
+                                    del_pipe.query_async(&mut conn).await;
+                                return Ok(false);
+                            }
+                            if let Ok(sc) = StatusCode::from_u16(ch.status) {
+                                status_code = sc;
+                            }
+                            parsed_headers = ch.headers;
+                            is_new_format = true;
+                        }
+                    }
+                }
+
+                debug!("Tier 2 HIT: {}", cache_key);
+                if let Some(timestamp) = self.encoding_hits.get(enc) {
+                    timestamp.store(now_secs, std::sync::atomic::Ordering::Relaxed);
+                }
+
+                let bytes = Bytes::from(cached_payload);
+
+                if let Ok(mut header) = ResponseHeader::build(status_code, None) {
+                    if is_new_format {
+                        for (name, value) in parsed_headers {
+                            if let (Ok(hname), Ok(hval)) = (
+                                http::header::HeaderName::try_from(name.as_str()),
+                                http::header::HeaderValue::try_from(value.as_str()),
+                            ) {
+                                let _ = header.insert_header(hname, hval);
+                            }
+                        }
+                    } else {
+                        let _ = header.insert_header("Content-Type", "text/html; charset=utf-8");
+                        let _ = header.insert_header("Content-Length", bytes.len().to_string());
+                    }
+
+                    if !enc.is_empty() {
+                        let _ = header.insert_header("Content-Encoding", enc);
+                    }
+
+                    self.tier1_cache
+                        .insert(cache_key.to_string(), (header.clone(), bytes.clone()))
+                        .await;
+                    let _ = header.insert_header("X-Cache-Tier", "2");
+
+                    let _ = session.write_response_header(Box::new(header), true).await;
+                    let _ = session.write_response_body(Some(bytes), true).await;
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    pub async fn fetch_from_cache(
+        &self,
+        session: &mut Session,
+        ctx: &mut ProxyCtx,
+        host: &str,
+        uri: &str,
+        query: &str,
+        encodings_to_check: &[&'static str],
+        now_secs: u64,
+    ) -> Result<bool> {
+        let base_cache_key = format!("{}{}{}", host, uri, query);
+
+        for enc in encodings_to_check.iter() {
+            let mut cache_key = base_cache_key.clone();
+            if !enc.is_empty() {
+                cache_key.push_str(&format!(":{}", enc));
+            }
+            ctx.cache_key = cache_key.clone();
+
+            // let now = std::time::Instant::now();
+            // Tier 1
+            if let Some((mut header, body)) = self.tier1_cache.get(&cache_key).await {
+                // println!("Tier 1 HIT: {:?}", now.elapsed());
+                debug!("Tier 1 HIT: {}", cache_key);
+                if let Some(timestamp) = self.encoding_hits.get(*enc) {
+                    timestamp.store(now_secs, std::sync::atomic::Ordering::Relaxed);
+                }
+
+                let _ = header.insert_header("X-Cache-Tier", "1");
+                session
+                    .write_response_header(Box::new(header), true)
+                    .await?;
+                session.write_response_body(Some(body), true).await?;
+                return Ok(true);
+            }
+
+            // Tier 2
+            if let Some(redis_url) = &self.config.redis_url {
+                if !redis_url.is_empty() {
+                    if self
+                        .fetch_from_redis(session, enc, host, &cache_key, redis_url, now_secs)
+                        .await?
+                    {
+                        return Ok(true);
+                    }
+                }
+            }
+        }
+
+        Ok(false)
+    }
+
+    pub fn spawn_cache_save(
+        &self,
+        host: String,
+        cache_key: String,
+        mut header: ResponseHeader,
+        html_bytes: Bytes,
+        redis_url_opt: Option<String>,
+        t2_ttl: u64,
+    ) {
+        let _ = header.remove_header("Transfer-Encoding");
+        let _ = header.insert_header("Content-Length", html_bytes.len().to_string());
+        let _ = header.remove_header("Cache-Control");
+
+        let content_encoding = header
+            .headers
+            .get("Content-Encoding")
+            .map(|hv| hv.to_str().unwrap_or(""))
+            .unwrap_or("")
+            .to_string();
+
+        let mut final_cache_key = cache_key;
+        if !content_encoding.is_empty() {
+            final_cache_key.push_str(&format!(":{}", content_encoding));
+        }
+
+        let sub_key = final_cache_key
+            .strip_prefix(&host)
+            .unwrap_or(&final_cache_key)
+            .to_string();
+
+        let tier1_cache = self.tier1_cache.clone();
+        tokio::spawn(async move {
+            tier1_cache
+                .insert(
+                    final_cache_key.clone(),
+                    (header.clone(), html_bytes.clone()),
+                )
+                .await;
+
+            if let Some(redis_url) = redis_url_opt {
+                if !redis_url.is_empty() {
+                    if let Some(mut conn) = get_redis_conn(&redis_url).await {
+                        let mut headers_vec = Vec::new();
+                        for (name, value) in header.headers.iter() {
+                            if let Ok(value_str) = value.to_str() {
+                                headers_vec
+                                    .push((name.as_str().to_string(), value_str.to_string()));
+                            }
+                        }
+
+                        let now_secs = std::time::SystemTime::now()
+                            .duration_since(std::time::UNIX_EPOCH)
+                            .unwrap_or(std::time::Duration::from_secs(0))
+                            .as_secs();
+
+                        let cached_headers = CachedHeaders {
+                            status: header.status.as_u16(),
+                            headers: headers_vec,
+                            expires_at: now_secs + t2_ttl,
+                        };
+
+                        let html_vec: Vec<u8> = html_bytes.into();
+                        if let Ok(headers_json) = serde_json::to_string(&cached_headers) {
+                            let headers_key = format!("{}:headers", sub_key);
+                            let mut pipe = redis::pipe();
+                            pipe.cmd("HSET")
+                                .arg(&host)
+                                .arg(&sub_key)
+                                .arg(html_vec)
+                                .cmd("HSET")
+                                .arg(&host)
+                                .arg(&headers_key)
+                                .arg(headers_json);
+                            let _: redis::RedisResult<()> = pipe.query_async(&mut conn).await;
+                        }
+                    }
+                }
+            }
+        });
+    }
+}