paru 0.99.2

Aur helper and pacman wrapper
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

use crate::config::Config;
use crate::download::Bases;
use crate::sprintln;
use crate::util::ask;

use std::collections::{HashMap, HashSet};
use std::process::Command;

use anyhow::{Context, Result};
use aur_depends::Base;
use srcinfo::Srcinfo;

pub fn check_pgp_keys(
    config: &Config,
    bases: &Bases,
    srcinfos: &HashMap<String, Srcinfo>,
) -> Result<()> {
    let mut import: HashMap<&str, Vec<&Base>> = HashMap::new();
    let mut seen = HashSet::new();
    let c = config.color;

    for base in &bases.bases {
        let pkg = base.package_base();
        let srcinfo = srcinfos.get(pkg).unwrap();
        for key in &srcinfo.base.valid_pgp_keys {
            if !seen.insert(key) {
                continue;
            }

            let ret = Command::new(&config.gpg_bin)
                .args(&config.gpg_flags)
                .arg("--list-keys")
                .arg(key)
                .output()?;

            if !ret.status.success() {
                import.entry(key).or_default().push(base);
            }
        }
    }

    if !import.is_empty() {
        sprintln!(
            "{} {}",
            c.action.paint("::"),
            c.bold.paint("keys need to be imported:")
        );
        for (key, base) in &import {
            let base = base.iter().map(|s| s.to_string()).collect::<Vec<_>>();
            sprintln!("     {} wanted by: {}", c.bold.paint(*key), base.join("  "));
        }
        if ask(config, "import?", true) {
            import_keys(config, &import)?;
        }
    }

    Ok(())
}

fn import_keys(config: &Config, import: &HashMap<&str, Vec<&Base>>) -> Result<()> {
    Command::new(&config.gpg_bin)
        .args(&config.gpg_flags)
        .arg("--recv-keys")
        .args(import.keys())
        .spawn()
        .with_context(|| {
            format!(
                "failed to run {} {} --resv-keys {}",
                config.gpg_bin,
                config.gpg_flags.join(" "),
                import.keys().cloned().collect::<Vec<_>>().join(" ")
            )
        })?
        .wait()
        .context("failed to import keys")?;

    Ok(())
}