nexus-gateway 0.0.1-alpha

S3-compatible object gateway and embedded Nexus console.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompressionPolicy {
    pub text_level: i32,
    pub entropy_bypass_threshold: f64,
    pub enable_bypass_for_precompressed: bool,
}

impl Default for CompressionPolicy {
    fn default() -> Self {
        Self {
            text_level: 3,
            entropy_bypass_threshold: 7.6,
            enable_bypass_for_precompressed: true,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CompressionCodec {
    Zstd,
    Bypass,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompressionDecision {
    pub codec: CompressionCodec,
    pub level: i32,
    pub bypass_reason: Option<String>,
    pub entropy_score: f64,
    pub mime: String,
}

impl CompressionDecision {
    pub fn to_json(&self) -> String {
        serde_json::to_string(self).unwrap_or_else(|_| "{}".to_string())
    }
}

pub fn decide(content_type: Option<&str>, payload: &[u8], policy: &CompressionPolicy) -> CompressionDecision {
    let mime = content_type.unwrap_or("application/octet-stream").to_ascii_lowercase();
    let entropy = shannon_entropy(payload);
    let looks_precompressed = mime.contains("zip")
        || mime.contains("gzip")
        || mime.contains("video/")
        || mime.contains("audio/")
        || mime.contains("image/")
        || mime.contains("application/pdf");

    if policy.enable_bypass_for_precompressed
        && looks_precompressed
        && entropy >= policy.entropy_bypass_threshold
    {
        return CompressionDecision {
            codec: CompressionCodec::Bypass,
            level: 0,
            bypass_reason: Some("high_entropy_or_precompressed".to_string()),
            entropy_score: entropy,
            mime,
        };
    }

    let level = if mime.contains("json") || mime.contains("text/") || mime.contains("xml") {
        policy.text_level.clamp(1, 5)
    } else {
        1
    };

    CompressionDecision {
        codec: CompressionCodec::Zstd,
        level,
        bypass_reason: None,
        entropy_score: entropy,
        mime,
    }
}

fn shannon_entropy(payload: &[u8]) -> f64 {
    if payload.is_empty() {
        return 0.0;
    }
    let mut counts = [0_u64; 256];
    for b in payload {
        counts[*b as usize] += 1;
    }
    let len = payload.len() as f64;
    let mut entropy = 0.0_f64;
    for c in counts {
        if c == 0 {
            continue;
        }
        let p = c as f64 / len;
        entropy -= p * p.log2();
    }
    entropy
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn text_payload_prefers_zstd() {
        let payload = b"{\"a\":1,\"b\":2}";
        let decision = decide(Some("application/json"), payload, &CompressionPolicy::default());
        assert!(matches!(decision.codec, CompressionCodec::Zstd));
        assert!(decision.level >= 1);
    }

    #[test]
    fn high_entropy_video_prefers_bypass() {
        let payload = (0..=255_u8).collect::<Vec<_>>();
        let decision = decide(Some("video/mp4"), &payload, &CompressionPolicy::default());
        assert!(matches!(decision.codec, CompressionCodec::Bypass));
    }
}