xianyun_core/

naming.rs

//! Port of `internal/naming`: cluster naming strategies for generating
//! deterministic, RFC 1123-compliant cluster names.

use thiserror::Error;

pub const PREFIX: &str = "xianyun";
/// The project's former name, recognized wherever a profile/directory
/// name might already carry it (so renaming the project doesn't
/// double-prefix directories literally named `caproni-something`, and
/// so a profile name generated before the rename is still recognized as
/// "already prefixed" by [`context_name`]). Not used to generate new
/// names -- only to recognize old ones.
const LEGACY_PREFIX: &str = "caproni";
pub const STRATEGY_STATIC: &str = "static";
pub const STRATEGY_DIR_HASH: &str = "directory-hash";

const MAX_LABEL_LENGTH: usize = 32;
const HASH_LENGTH: usize = 6;
const SEPARATOR_COUNT: usize = 2;
const RESERVED_FOR_SUFFIX: usize = HASH_LENGTH + SEPARATOR_COUNT;

#[derive(Debug, Error, PartialEq, Eq)]
pub enum NamingError {
    #[error("unknown naming strategy: {0}")]
    UnknownStrategy(String),
}

/// Resolves the naming strategy together with the config directory to
/// generate a profile name for the cluster.
pub fn resolve(strategy: &str, config_dir: &str) -> Result<String, NamingError> {
    match strategy {
        STRATEGY_STATIC | "" => Ok(PREFIX.to_string()),
        STRATEGY_DIR_HASH => Ok(create_directory_hash(config_dir)),
        other => Err(NamingError::UnknownStrategy(other.to_string())),
    }
}

/// Returns the kubeconfig context name for a profile.
pub fn context_name(profile: &str) -> String {
    if profile.is_empty() {
        return PREFIX.to_string();
    }

    if profile == PREFIX
        || profile.starts_with(&format!("{PREFIX}-"))
        || profile == LEGACY_PREFIX
        || profile.starts_with(&format!("{LEGACY_PREFIX}-"))
    {
        return profile.to_string();
    }

    format!("{PREFIX}-{profile}")
}

fn create_directory_hash(config_dir: &str) -> String {
    let dir_name = base_name(config_dir);
    let hash = &sha256sum(config_dir)[..HASH_LENGTH];

    let mut sanitized = to_rfc1123_label(dir_name);

    if let Some(stripped) = sanitized
        .strip_prefix(PREFIX)
        .or_else(|| sanitized.strip_prefix(LEGACY_PREFIX))
    {
        sanitized = stripped.to_string();
    }

    let max_dir_len = MAX_LABEL_LENGTH - PREFIX.len() - RESERVED_FOR_SUFFIX;
    if sanitized.len() > max_dir_len {
        sanitized.truncate(max_dir_len);
    }
    sanitized = sanitized.trim_matches('-').to_string();

    if sanitized.is_empty() {
        return format!("{PREFIX}-{hash}");
    }

    format!("{PREFIX}-{sanitized}-{hash}")
}

fn base_name(path: &str) -> &str {
    let trimmed = path.trim_end_matches('/');
    if trimmed.is_empty() {
        return "/";
    }
    trimmed.rsplit('/').next().unwrap_or(trimmed)
}

fn to_rfc1123_label(s: &str) -> String {
    let lower = s.to_lowercase();
    let mut out = String::with_capacity(lower.len());
    for c in lower.chars() {
        if c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-' {
            out.push(c);
        } else {
            out.push('-');
        }
    }

    // collapse runs of '-'
    let mut collapsed = String::with_capacity(out.len());
    let mut prev_hyphen = false;
    for c in out.chars() {
        if c == '-' {
            if !prev_hyphen {
                collapsed.push(c);
            }
            prev_hyphen = true;
        } else {
            collapsed.push(c);
            prev_hyphen = false;
        }
    }

    collapsed.trim_matches('-').to_string()
}

fn sha256sum(s: &str) -> String {
    use sha2::{Digest, Sha256};
    let mut hasher = Sha256::new();
    hasher.update(s.as_bytes());
    let digest = hasher.finalize();
    digest.iter().map(|b| format!("{b:02x}")).collect()
}

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

    // Port of TestResolve (internal/naming/naming_test.go).
    #[test]
    fn resolve_cases() {
        let rfc1123 = |s: &str| -> bool {
            !s.is_empty()
                && s.chars()
                    .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
                && !s.starts_with('-')
                && !s.ends_with('-')
        };

        let cases: &[(&str, &str, &str, Option<&str>)] = &[
            (
                "static strategy",
                STRATEGY_STATIC,
                "/any/path",
                Some("xianyun"),
            ),
            (
                "empty strategy defaults to static",
                "",
                "/any/path",
                Some("xianyun"),
            ),
            (
                "unknown strategy returns error",
                "random",
                "/any/path",
                None,
            ),
            (
                "directory-hash basic",
                STRATEGY_DIR_HASH,
                "/home/user/demo",
                Some("xianyun-demo-9fd39f"),
            ),
            (
                "directory-hash uppercase coerced",
                STRATEGY_DIR_HASH,
                "/home/user/UPPER",
                Some("xianyun-upper-ce5dc1"),
            ),
            (
                "directory-hash special chars",
                STRATEGY_DIR_HASH,
                "/home/user/My Project!",
                Some("xianyun-my-project-148160"),
            ),
            (
                "directory-hash deterministic",
                STRATEGY_DIR_HASH,
                "/home/user/demo",
                Some("xianyun-demo-9fd39f"),
            ),
            (
                "directory-hash different path same dirname",
                STRATEGY_DIR_HASH,
                "/other/path/demo",
                Some("xianyun-demo-d2c668"),
            ),
            (
                "directory-hash with dashes",
                STRATEGY_DIR_HASH,
                "/other/path/-demo-",
                Some("xianyun-demo-2a331e"),
            ),
            (
                "directory-hash caproni prefix (legacy project name, still stripped)",
                STRATEGY_DIR_HASH,
                "/other/path/caproni-demo",
                Some("xianyun-demo-5a3655"),
            ),
            (
                "directory-hash xianyun prefix",
                STRATEGY_DIR_HASH,
                "/other/path/xianyun-demo",
                Some("xianyun-demo-a0b29d"),
            ),
            (
                "directory-hash all special chars dir",
                STRATEGY_DIR_HASH,
                "/home/user/---special---",
                Some("xianyun-special-e1a6cf"),
            ),
            (
                "directory-hash root dir",
                STRATEGY_DIR_HASH,
                "/",
                Some("xianyun-8a5eda"),
            ),
        ];

        for (name, strategy, dir, want) in cases {
            let got = resolve(strategy, dir);
            match want {
                Some(expected) => {
                    let result = got.unwrap_or_else(|e| panic!("{name}: unexpected error {e}"));
                    assert_eq!(&result, expected, "{name}");
                    assert!(result.len() <= MAX_LABEL_LENGTH, "{name}");
                    assert!(rfc1123(&result), "{name}");
                }
                None => {
                    assert!(got.is_err(), "{name}: expected error");
                }
            }
        }
    }

    // Port of TestResolve's directory-hash long dirname truncated case, split
    // out because it needs a computed `str::repeat` expected value.
    #[test]
    fn resolve_long_dirname_is_truncated() {
        let dir = format!("/home/user/{}", "a".repeat(100));
        let want = format!("xianyun-{}-a90ac6", "a".repeat(17));
        assert_eq!(resolve(STRATEGY_DIR_HASH, &dir).unwrap(), want);
    }

    // Port of TestToRFC1123Label.
    #[test]
    fn to_rfc1123_label_cases() {
        let cases = [
            ("demo", "demo"),
            ("UPPER", "upper"),
            ("My Project!", "my-project"),
            ("---hyphens---", "hyphens"),
            ("hello_world", "hello-world"),
            ("a..b", "a-b"),
            ("/", ""),
            ("", ""),
        ];

        for (input, expected) in cases {
            assert_eq!(to_rfc1123_label(input), expected, "{input}");
        }
    }

    // Port of TestContextName.
    #[test]
    fn context_name_cases() {
        let cases = [
            ("xianyun", "xianyun"),
            ("xianyun-demo-d06f00d", "xianyun-demo-d06f00d"),
            ("xianyun-x", "xianyun-x"),
            ("demo", "xianyun-demo"),
            ("", "xianyun"),
            ("xianyunify", "xianyun-xianyunify"),
            ("xianyunix", "xianyun-xianyunix"),
            // Profile names generated before the xianyun rename are still
            // recognized as already-prefixed (the legacy "caproni" prefix),
            // not double-prefixed into "xianyun-caproni-...".
            ("caproni", "caproni"),
            ("caproni-demo-d06f00d", "caproni-demo-d06f00d"),
            ("caproni-x", "caproni-x"),
            ("capronify", "xianyun-capronify"),
            ("capronix", "xianyun-capronix"),
        ];

        for (input, expected) in cases {
            assert_eq!(context_name(input), expected, "{input}");
        }
    }
}