nora-registry 1.2.2

Cloud-Native Artifact Registry - Fast, lightweight, multi-protocol
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

// Copyright (c) 2026 The NORA Authors
// SPDX-License-Identifier: MIT

use crate::secrets::ProtectedString;
use serde::{Deserialize, Serialize};
use std::env;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MavenConfig {
    #[serde(default = "super::super::default_true")]
    pub enabled: bool,
    #[serde(default = "default_maven_proxies")]
    pub proxies: Vec<MavenProxyEntry>,
    #[serde(default = "super::super::default_timeout")]
    pub proxy_timeout: u64,
    /// Verify client-uploaded checksums against server-computed values
    #[serde(default = "super::super::default_true")]
    pub checksum_verify: bool,
    /// Prevent overwriting released (non-SNAPSHOT) artifacts
    #[serde(default = "super::super::default_true")]
    pub immutable_releases: bool,
    /// Staleness window (seconds) for mutable metadata (maven-metadata.xml, SNAPSHOT); a
    /// non-positive value revalidates every pull. Release artifacts are always immutable.
    #[serde(default = "super::super::default_metadata_ttl")]
    pub metadata_ttl: i64,
}

/// Maven upstream proxy configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum MavenProxyEntry {
    Simple(String),
    Full(MavenProxy),
}

/// Maven upstream proxy with optional auth
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MavenProxy {
    pub url: String,
    #[serde(default, skip_serializing)]
    pub auth: Option<ProtectedString>,
}

impl MavenProxyEntry {
    pub fn url(&self) -> &str {
        match self {
            MavenProxyEntry::Simple(s) => s,
            MavenProxyEntry::Full(p) => &p.url,
        }
    }
    pub fn auth(&self) -> Option<&str> {
        use crate::secrets::expose_opt;
        match self {
            MavenProxyEntry::Simple(_) => None,
            MavenProxyEntry::Full(p) => expose_opt(&p.auth),
        }
    }
}

/// Default Maven upstream. Single source for the serde field-default and the
/// `Default` impl so a present-but-empty `[maven]` table keeps the upstream
/// instead of silently going local-only (the npm/pypi `#[serde(default)]`
/// divergence class — a bare default on a `Vec` yields an empty list).
fn default_maven_proxies() -> Vec<MavenProxyEntry> {
    vec![MavenProxyEntry::Simple(
        "https://repo1.maven.org/maven2".to_string(),
    )]
}

impl Default for MavenConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            proxies: default_maven_proxies(),
            proxy_timeout: 30,
            checksum_verify: true,
            immutable_releases: true,
            metadata_ttl: 300,
        }
    }
}

impl MavenConfig {
    pub(in crate::config) fn apply_env_overrides(&mut self) {
        if let Ok(val) = env::var("NORA_MAVEN_ENABLED") {
            self.enabled = val.to_lowercase() == "true" || val == "1";
        }
        if let Ok(val) = env::var("NORA_MAVEN_PROXIES") {
            self.proxies = val
                .split(',')
                .filter(|s| !s.is_empty())
                .map(|s| {
                    let parts: Vec<&str> = s.trim().splitn(2, '|').collect();
                    if parts.len() > 1 {
                        MavenProxyEntry::Full(MavenProxy {
                            url: parts[0].to_string(),
                            auth: Some(ProtectedString::from(parts[1])),
                        })
                    } else {
                        MavenProxyEntry::Simple(parts[0].to_string())
                    }
                })
                .collect();
        }
        if let Ok(val) = env::var("NORA_MAVEN_PROXY_TIMEOUT") {
            super::super::parse_env_warn("NORA_MAVEN_PROXY_TIMEOUT", &val, &mut self.proxy_timeout);
        }
        if let Ok(val) = env::var("NORA_MAVEN_CHECKSUM_VERIFY") {
            self.checksum_verify = val.to_lowercase() == "true" || val == "1";
        }
        if let Ok(val) = env::var("NORA_MAVEN_IMMUTABLE_RELEASES") {
            self.immutable_releases = val.to_lowercase() == "true" || val == "1";
        }
        if let Ok(val) = env::var("NORA_MAVEN_METADATA_TTL") {
            super::super::parse_env_warn("NORA_MAVEN_METADATA_TTL", &val, &mut self.metadata_ttl);
        }
    }
}