woz 1.1.1

Woz is a WebAssembly progressive web app (PWA) toolchain for deploying performant mobile apps distributed for free with a hyperlink. 
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

use rusoto_s3::*;
use rusoto_core::ByteStream;
use failure::Error;
use failure::ResultExt;
use crate::config::S3_BUCKET_NAME;


/// Represents a file to be uploaded. File contents are held in memory
/// as a vector of bytes. This may not be desireable for very large
/// files...
pub struct FileUpload {
    pub key: String,
    pub mimetype: String,
    pub bytes: Vec<u8>
}

impl FileUpload {
    pub fn new(key: String, mimetype: String, bytes: Vec<u8>) -> Self {
        Self {key, mimetype, bytes}
    }
}

pub trait AppComponent {
    /// Returns a collection of file uploads to be added to be added
    /// to the application. Ordering does not matter.
    fn files(&self, file_prefix: &String) -> Result<Vec<FileUpload>, Error>;
}

/// Builds the application bundle, a collection of files to be
/// uploaded. You can extend the app build by implementing the
/// AppComponent trait and adding it to the build via
/// the `component` method.
pub struct AppBuilder {
    file_prefix: String,
    client: S3Client,
    pub inner: Vec<FileUpload>,
}

impl AppBuilder {
    pub fn new(client: S3Client, file_prefix: String) -> Self {
        Self { client, file_prefix, inner: Vec::new() }
    }
}

impl AppBuilder {
    /// Add the component to the build
    pub fn component<T>(&mut self, component: T) -> &mut Self
    where T:AppComponent {
        let files = component.files(&self.file_prefix).unwrap();
        for f in files.into_iter() {
            self.inner.push(f);
        };
        self
    }

    /// Returns the size of the overall application
    fn size(&self) -> usize {
        unimplemented!("TODO");
    }

    pub fn upload(&self) -> Result<(), Error> {
        for FileUpload {key, mimetype, bytes} in self.inner.iter() {
            let req = PutObjectRequest {
                bucket: String::from(S3_BUCKET_NAME),
                key: key.to_owned(),
                body: Some(ByteStream::from(bytes.to_owned())),
                content_type: Some(mimetype.to_owned()),
                ..Default::default()
            };

            self.client.put_object(req)
                .sync()
                .context(format!("Failed to upload file to S3: {}", key))?;
        };
        Ok(())
    }
}