packager/bootpkg/src/main.rs

use std::env;
use std::env::temp_dir;
use std::fs::{create_dir_all, File, remove_dir_all};
use std::io::Write;
use std::process::exit;

use uuid::Uuid;

use pkgfile::PKGFile;

use crate::args::{Args, Command};

mod args;
mod prelude;

fn main() {
    let args = Args::from(env::args().collect::<Vec<String>>()[1..].to_owned());
    match args.command {
        Command::Strap => {
            if args.args.len() == 0 {
                println!("no path/uri");
                exit(0);
            }
            let uri = &args.args[0];
            println!("!! Got package: \"{}\"", uri);
            let re = r"[A-z]+://.+";
            let data = if regex::Regex::new(re).unwrap().is_match(uri) {
                println!("** detected uri.");
                reqwest::blocking::get(uri)
                    .expect("Could not request file.")
                    .bytes()
                    .expect("Could not turn file into bytes.")
                    .to_vec()
            } else {
                println!("** reading data...");
                if let Ok(d) = std::fs::read(uri) {
                    d
                } else {
                    println!("Could not read file!");
                    exit(1);
                }
            };

            println!("** parsing pkgfile...");
            let pkg = match PKGFile::try_from(data) {
                Ok(p) => p,
                Err(_) => {
                    println!("!! Could not interpret PKGFile...");
                    exit(1);
                }
            };

            let mani = prelude::mani_from_str(&pkg.manifest);

            println!("-- Package: {}", &mani.package.name);
            println!("-- Description: {}", &mani.package.description);
            println!("-- Version: {}", &mani.package.version);
            println!("-- Tags: {}", &mani.package.tags.join(", "));

            if !mani.valid() {
                println!("!!! Manifest is not valid.");
                exit(1);
            }

            let mut tmp_dir = temp_dir();
            tmp_dir.push(format!("{}", Uuid::new_v4()));
            create_dir_all(&tmp_dir)
                .expect("Could not create tmp dir.");

            {
                println!("** writing tar to tmp file...");
                let mut file = File::create(format!("{}/pkgtar", tmp_dir.to_str().unwrap_or("/tmp")))
                    .expect("Could not create tmp pkgtar file");

                file.write(&pkg.data)
                    .expect("Could not write pkgtar to tmp file");
            }


            // TODO: untar
            // TODO: cd into pkg
            // TODO: run bootstrap commands

            println!("** removing temporary directory...");
            remove_dir_all(&tmp_dir)
                .expect(&*format!("Could not remove tmp dir: {}", &tmp_dir.to_str().unwrap()));
        }
        Command::Unpack => {}
        _ => {
            println!("Unsupported command, allowed commands: strap/unpack.");
            exit(1);
        }
    }
}