bindle 0.9.1

An aggregate object storage system for applications
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
118
119
120
121
122
123
124
125
126
127
128
129

use clap::{App, Arg};
use serde::Deserialize;
use sha2::Digest;
use tokio::fs;
use tokio::io::AsyncSeekExt;

use std::collections::HashMap;
use std::io::SeekFrom;
use std::path::Path;

const DESCRIPTION: &str = r#"
Transform an AssemblyScript project to a bindle.

This reads a package.json file and the build/ directory to construct a
Bindle from the data.

By default, it attempts to read the local package.json and build/ directory,
and then write the results to a bindir/ directory as a standalone bindle.
"#;

#[tokio::main]
async fn main() {
    let app = App::new("as2bindle")
        .version(clap::crate_version!())
        .author("DeisLabs at Microsoft Azure")
        .about(DESCRIPTION)
        .arg(
            Arg::new("src")
                .help("path to directory with package.json")
                .short('s')
                .long("src")
                .takes_value(true),
        )
        .arg(
            Arg::new("bindir")
                .help("path to bindle directory")
                .short('b')
                .long("bindle")
                .takes_value(true),
        )
        .get_matches();
    let src_dir = app.value_of("src").unwrap_or("./");
    let bindle_dir = app.value_of("bindir").unwrap_or("./");

    let src_path = Path::new(src_dir);
    let bindle_path = Path::new(bindle_dir);

    // Find and read package.json
    let package_json = fs::read(src_path.join("package.json"))
        .await
        .expect("failed to read package.json");
    let package: Package =
        serde_json::from_slice(&package_json).expect("failed to parse package.json");
    // Find target wasm
    let path = src_path.join("build/optimized.wasm");
    if !path.is_file() {
        panic!("no optimized.wasm found in build directory");
    }

    // Calculate the hash of the WASM file
    let mut file = tokio::fs::File::open(&path)
        .await
        .expect("file cannot be opened");
    let mut hasher = bindle::async_util::AsyncSha256::new();
    tokio::io::copy(&mut file, &mut hasher)
        .await
        .expect("hashing file failed");
    let sha = format!("{:x}", hasher.into_inner().unwrap().finalize());
    file.seek(SeekFrom::Start(0))
        .await
        .expect("failed to seek to beginning of WASM file");

    let mut parcels = HashMap::new();
    parcels.insert(sha.clone(), file);

    // Create the label object
    let md = tokio::fs::metadata(&path).await.expect("failed to stat");
    let label = bindle::Label {
        name: format!("{}", path.file_name().unwrap().to_string_lossy()),
        media_type: "application/wasm".to_owned(),
        sha256: sha,
        size: md.len(),
        ..bindle::Label::default()
    };

    // Return the parcel section to be added to the invoice.
    // Create invoice
    let mut invoice = bindle::Invoice {
        bindle_version: bindle::BINDLE_VERSION_1.to_owned(),
        yanked: None,
        yanked_signature: None,
        bindle: bindle::BindleSpec {
            id: format!("{}/{}", package.name, package.version)
                .parse()
                .expect("Missing name or version information"),
            authors: None,
            description: package.description,
        },
        parcel: Some(vec![bindle::Parcel {
            label,
            conditions: None,
        }]),
        annotations: None,
        group: None,
        signature: None,
    };

    if let Some(auth) = package.author {
        invoice.bindle.authors = Some(vec![auth])
    }

    // Write invoice
    let standalone = bindle::standalone::StandaloneWrite::new(bindle_path, &invoice.bindle.id)
        .await
        .unwrap();
    standalone
        .write(invoice, parcels)
        .await
        .expect("unable to write bindle");
    println!("Wrote bindle to {}", standalone.path().display());
}

#[derive(Deserialize)]
struct Package {
    name: String,
    version: String,
    author: Option<String>,
    description: Option<String>,
}