bpt 0.1.6

Bedrock Linux package manager
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::constant::*;
use crate::{cli::*, collection::*, color::Color, error::*, file::*, io::*, reconcile::*};
use camino::{Utf8Path, Utf8PathBuf};
use std::fs::File;
use std::{cell::RefCell, time::SystemTime};

/// Filter the list of files by the specified file type, then load the given file type.
macro_rules! current {
    ($files:ident, $ext:literal, $ty:ty, $pubkeys:ident) => {
        $files
            .iter()
            .filter(|(path, _)| path.extension() == Some($ext))
            .map(|(path, mtime)| {
                <$ty>::from_file(File::open_ro(path)?, $pubkeys)
                    .map(|file| (*mtime, (*path).as_path(), file))
                    .loc(path)
            })
            .collect::<Result<Vec<_>, _>>()
    };
}

/// Collect all the file paths and their modified times currently in the given directory
fn current_files(dir: &Utf8Path) -> Result<Vec<(Utf8PathBuf, SystemTime)>, Err> {
    dir.readdir()?
        .map(|path| {
            path.metadata()
                .and_then(|meta| meta.modified())
                .map_err(|e| Err::Stat(path.to_owned(), e))
                .map(|mtime| (path, mtime))
        })
        .collect::<Result<Vec<_>, _>>()
}

pub fn make_repo(flags: CommonFlags) -> Result<String, Err> {
    let pubkeys = &PublicKeys::from_common_flags(&flags)?;
    let bpt_conf = &BptConf::from_root_path(&flags.root_dir)?;
    let build_credentials = bpt_conf.build_credentials()?;

    let files = current_files(&flags.out_dir)?;
    let bbuilds = files
        .iter()
        .filter(|(path, _)| path.extension() == Some("bbuild"))
        .map(|(path, mtime)| {
            Bbuild::from_file(File::open_ro(path)?, pubkeys, build_credentials.as_ref())
                .map(|file| (*mtime, (*path).as_path(), file))
                .loc(path)
        })
        .collect::<Result<Vec<_>, _>>()?;
    if bbuilds.is_empty() {
        return Err(Err::MakeRepoNoBbuilds(flags.out_dir.to_owned()));
    }
    let bpts = current!(files, "bpt", Bpt, pubkeys)?;
    let pkgidxs = current!(files, "pkgidx", PkgIdx, pubkeys)?;
    let fileidxs = current!(files, "fileidx", FileIdx, pubkeys)?;
    let installed_pkgs = &InstalledPkgs::from_root_path_ro(&flags.root_dir)?;
    let mut available_bpts_new = AvailableBpts::new();
    for (_, path, _) in &bpts {
        let bpt = Bpt::from_file(File::open_ro(path)?, pubkeys).loc(path)?;
        available_bpts_new.add(bpt);
    }
    let available_bpts = &RefCell::new(available_bpts_new);

    let bpt_rec = BptReconciler::new(&bbuilds, &bpts, bpt_conf);
    let pkgidx_rec = PkgIdxReconciler::new(&bbuilds, &pkgidxs, bpt_conf)?;
    let fileidx_rec = FileIdxReconciler::new(&bbuilds, &fileidxs, bpt_conf)?;

    let bpt_plan = bpt_rec.plan();
    let pkgidx_plan = pkgidx_rec.plan();
    let fileidx_plan = fileidx_rec.plan();

    if bpt_plan.is_empty() && pkgidx_plan.is_empty() && fileidx_plan.is_empty() {
        return Ok("No changes needed".to_string());
    }

    if flags.dry_run {
        println!(
            "{}Would have:{}\n{bpt_plan}{pkgidx_plan}{fileidx_plan}",
            Color::Warn,
            Color::Default
        );
        return Ok(format!(
            "Dry ran make-repo of {} *.bbuild file(s)",
            bbuilds.len()
        ));
    }

    println!("Continuing will:\n{bpt_plan}{pkgidx_plan}{fileidx_plan}");
    if !flags.yes && !confirm()? {
        return Err(Err::ConfirmDenied);
    }

    // Typically, resources like privkey are collected at the very top of a per-command function.
    // However, here we want to delay collecting privkey until after confirming we actually need to
    // make changes to to avoid an unnecessary privkey password prompt.
    let privkey = &PrivKey::from_common_flags(&flags)?;

    let netutil = &RefCell::new(NetUtil::new(bpt_conf, flags.netutil_stderr));
    let tmpdir = &RefCell::new(TmpDir::new(bpt_conf)?);
    let src_cache = &RefCell::new(Cache::from_root_path(
        &flags.root_dir,
        SRC_CACHE,
        "source cache",
    )?);

    let buildargs = BuildArgs {
        privkey,
        build_credentials: build_credentials.as_ref(),
        make_conf: &MakeConf::from_root_path(&flags.root_dir)?,
        make_common: &MakeCommon::from_root_path(&flags.root_dir)?,
        out_dir: &flags.out_dir,
        root_dir: &flags.root_dir.adjust_bedrock_prefix()?,
        tmpdir,
        netutil,
        src_cache,
        installed_pkgs,
        available_bpts,
    };
    bpt_plan.apply(&buildargs)?;
    pkgidx_plan.apply(&PkgIdxRecArgs {
        dir: &flags.out_dir,
        privkey,
        pubkeys,
    })?;
    fileidx_plan.apply(&FileIdxRecArgs {
        dir: &flags.out_dir,
        privkey,
        pubkeys,
    })?;

    Ok(format!(
        "Updated repository files from {} *.bbuild file(s)",
        bbuilds.len()
    ))
}