bulk 0.4.6

A simple tool for making deb packages, repositories, and update version numbers. 
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

mod metadata;
mod ar;
mod deb;
mod debian;

use std::io::{stdout, stderr, Write};
use std::path::{Path, PathBuf};
use std::error::Error;
use std::process::exit;

use regex::Regex;
use argparse::{ArgumentParser, Parse, Collect, StoreConst};

use config::{Config, RepositoryType};
use repo::metadata::gather_metadata;


fn _repo_add(config: &Path, packages: &Vec<String>, dir: &Path,
    on_conflict: debian::ConflictResolution)
    -> Result<(), Box<Error>>
{
    let packages = try!(packages.iter().map(gather_metadata)
        .collect::<Result<Vec<_>, _>>());
    debug!("Packages read {:#?}", packages);
    let cfg = try!(Config::parse_file(&config));
    let mut debian = debian::Repository::new(dir);

    for repo in &cfg.repositories {
        let version_re = match repo.match_version {
            Some(ref re) => Some(try!(Regex::new(re))),
            None => None,
        };
        let skip_re = match repo.skip_version {
            Some(ref re) => Some(try!(Regex::new(re))),
            None => None,
        };
        let matching = packages.iter()
            .filter(|p| {
                version_re.as_ref().map(|x| x.is_match(&p.version))
                .unwrap_or(true) &&
                !skip_re.as_ref().map(|x| x.is_match(&p.version))
                .unwrap_or(false)
            })
            .collect::<Vec<_>>();
        if matching.len() > 0 {
            match (repo.kind, &repo.suite, &repo.component) {
                (RepositoryType::debian, &Some(ref suite), &Some(ref comp))
                => {
                    for p in matching {
                        try!(try!(debian.open(suite, comp, &p.arch))
                            .add_package(p, on_conflict));
                        if repo.add_empty_i386_repo && p.arch != "i386" {
                            try!(debian.open(suite, comp, "i386"));
                        }
                    }
                }
                (RepositoryType::debian, _, _) => {
                    return Err("Debian repository requires suite and \
                               component to be specified".into());

                }
            }
        }
    }
    for repo in cfg.repositories {
        match (repo.kind, &repo.suite, &repo.component) {
            (RepositoryType::debian, &Some(ref suite), &Some(ref comp)) => {
                if let Some(limit) = repo.keep_releases {
                    debian.trim(suite, comp, limit);
                }
            }
            _ => unreachable!(),
        }
    }
    try!(debian.write());
    // TODO(tailhook) remove removed files
    Ok(())
}


pub fn repo_add(args: Vec<String>) {
    let mut config = PathBuf::from("bulk.yaml");
    let mut repo_dir = PathBuf::new();
    let mut packages = Vec::<String>::new();
    let mut conflict = debian::ConflictResolution::Error;
    {
        let mut ap = ArgumentParser::new();
        ap.refer(&mut config)
            .add_option(&["-c", "--config"], Parse,
                "Package configuration file");
        ap.refer(&mut repo_dir)
            .add_option(&["-D", "--repository-base"], Parse,
                "Directory where repositories are stored");
        ap.refer(&mut conflict)
            .add_option(&["--skip-existing"],
                StoreConst(debian::ConflictResolution::Keep),
                "Skip package if it's already in the repository")
            .add_option(&["--replace-existing"],
                StoreConst(debian::ConflictResolution::Replace),
                "Replace package if it's already in the repository");
        ap.refer(&mut packages)
            .add_argument("packages", Collect,
                "Package file names to add");
        match ap.parse(args, &mut stdout(), &mut stderr()) {
            Ok(()) => {}
            Err(x) => exit(x),
        }
    }

    match _repo_add(&config, &packages, &repo_dir, conflict) {
        Ok(()) => {}
        Err(err) => {
            writeln!(&mut stderr(), "Error: {}", err).ok();
            exit(1);
        }
    }
}