pkgsrc 0.10.0

Rust interface to pkgsrc packages and infrastructure
Documentation 
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

use pkgsrc::{DependError, PatternCache, PatternError, PkgName, ScanIndex};
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::BufReader;
use std::path::PathBuf;
use std::time::Instant;

#[derive(Debug, thiserror::Error)]
enum ResolveError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Depend(#[from] DependError),
    #[error(transparent)]
    Pattern(#[from] PatternError),
}

fn load_scan_index() -> Result<Vec<ScanIndex>, ResolveError> {
    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("tests/data/scanindex/pscan.zstd");

    let file = File::open(&path)?;
    let decoder = zstd::stream::Decoder::new(file)?;
    let reader = BufReader::new(decoder);

    Ok(ScanIndex::from_reader(reader).collect::<Result<Vec<_>, _>>()?)
}

#[test]
fn resolve_full_scan() -> Result<(), ResolveError> {
    let start = Instant::now();
    let packages = load_scan_index()?;
    let load_time = start.elapsed();

    let has_reason =
        |r: &Option<String>| r.as_ref().is_some_and(|s| !s.is_empty());

    // Collect all package names for pattern matching
    let pkgnames: Vec<&PkgName> = packages.iter().map(|p| &p.pkgname).collect();

    // Build index by package base name for fast lookups
    let mut by_base: HashMap<&str, Vec<&PkgName>> = HashMap::new();
    for pkg in &pkgnames {
        by_base.entry(pkg.pkgbase()).or_default().push(pkg);
    }

    let start = Instant::now();
    let mut total_patterns = 0usize;
    let mut unresolved: Vec<(String, String)> = Vec::new();
    let mut cache = PatternCache::with_capacity(packages.len());

    for pkg in &packages {
        if has_reason(&pkg.pkg_skip_reason) || has_reason(&pkg.pkg_fail_reason)
        {
            continue;
        }
        let Some(deps) = &pkg.all_depends else {
            continue;
        };

        for dep in deps {
            let dep = dep?;
            total_patterns += 1;
            let pattern = cache.compile(dep.pattern())?;

            let candidates: &[&PkgName] = match pattern.pkgbase() {
                Some(base) => {
                    by_base.get(base).map(|v| v.as_slice()).unwrap_or(&[])
                }
                None => &pkgnames,
            };

            let mut best: Option<&str> = None;
            for candidate in candidates {
                best = pattern.best_match_pbulk(best, candidate.pkgname())?;
            }

            if best.is_none() {
                unresolved.push((
                    pattern.pattern().to_string(),
                    pkg.pkgname.to_string(),
                ));
            }
        }
    }

    let resolve_time = start.elapsed();

    eprintln!("Packages:     {}", packages.len());
    eprintln!("Patterns:     {}", total_patterns);
    eprintln!("Unresolved:   {}", unresolved.len());
    eprintln!("Load time:    {:?}", load_time);
    eprintln!("Resolve time: {:?}", resolve_time);

    let expected: HashSet<(&str, &str)> = [
        ("py311-buildbot-[0-9]*", "py311-buildbot-badges-2.6.0nb1"),
        (
            "py311-buildbot-[0-9]*",
            "py311-buildbot-waterfall-view-2.6.0nb1",
        ),
        ("py311-stevedore>=1.20.0", "py311-e3-core-22.10.0nb3"),
        ("py312-daemon>=2.3.0", "py312-libagent-0.15.0"),
        ("py313-daemon>=2.3.0", "py313-libagent-0.15.0"),
        ("py314-daemon>=2.3.0", "py314-libagent-0.15.0"),
    ]
    .into_iter()
    .collect();

    let actual: HashSet<(&str, &str)> = unresolved
        .iter()
        .map(|(p, pkg)| (p.as_str(), pkg.as_str()))
        .collect();

    assert_eq!(actual, expected, "unresolved dependencies mismatch");

    Ok(())
}