polywrap_wasm 0.1.11

Rust implementation of WASM runtime compliant with WRAP standard
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::{
    fmt::{Debug, Formatter},
    sync::{Arc, Mutex},
};

use polywrap_core::{
    file_reader::FileReader,
    package::{GetManifestOptions, WrapPackage},
    wrapper::Wrapper,
};
use wrap_manifest_schemas::{
    deserialize::{deserialize_wrap_manifest, DeserializeManifestOptions},
    versions::WrapManifest,
};

use crate::{
    error::WrapperError,
    wasm_module::{CompiledWasmModule, WasmModule},
    wasm_wrapper::WasmWrapper,
};

use super::file_reader::InMemoryFileReader;

pub struct WasmPackage {
    file_reader: Arc<dyn FileReader>,
    manifest: Option<Vec<u8>>,
    wasm_module: Arc<Mutex<Option<WasmModule>>>,
}

impl WasmPackage {
    pub fn from_bytecode(
        wasm_bytes: Vec<u8>,
        file_reader: Arc<dyn FileReader>,
        manifest: Option<Vec<u8>>,
    ) -> Self {
        Self {
            file_reader: Arc::new(InMemoryFileReader::new(
                file_reader,
                None,
                Some(wasm_bytes.clone()),
            )),
            manifest,
            wasm_module: Arc::new(Mutex::new(Some(WasmModule::WasmBytecode(
                wasm_bytes.into(),
            )))),
        }
    }

    pub fn from_file_reader(file_reader: Arc<dyn FileReader>, manifest: Option<Vec<u8>>) -> Self {
        Self {
            file_reader,
            manifest,
            wasm_module: Arc::new(Mutex::new(None)),
        }
    }

    pub fn from_compiled_module(
        wasm_module: CompiledWasmModule,
        wasm_bytes: Vec<u8>,
        file_reader: Arc<dyn FileReader>,
        manifest: Option<Vec<u8>>,
    ) -> Self {
        Self {
            file_reader: Arc::new(InMemoryFileReader::new(file_reader, None, Some(wasm_bytes))),
            manifest,
            wasm_module: Arc::new(Mutex::new(Some(WasmModule::Compiled(wasm_module)))),
        }
    }

    pub fn from_wasm_module(
        wasm_module: WasmModule,
        wasm_bytes: Vec<u8>,
        file_reader: Arc<dyn FileReader>,
        manifest: Option<Vec<u8>>,
    ) -> Self {
        Self {
            file_reader: Arc::new(InMemoryFileReader::new(file_reader, None, Some(wasm_bytes))),
            manifest,
            wasm_module: Arc::new(Mutex::new(Some(wasm_module))),
        }
    }

    pub fn get_wasm_module(&self) -> Result<Vec<u8>, polywrap_core::error::Error> {
        let file_content = self.file_reader.read_file("wrap.wasm")?;

        Ok(file_content)
    }
}

impl PartialEq for WasmPackage {
    fn eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl Debug for WasmPackage {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(
            f,
            r#"
        WasmPackage
        
        -Manifest: {:?}
        "#,
            self.manifest
        )
    }
}

impl WrapPackage for WasmPackage {
    fn get_manifest(
        &self,
        options: Option<&GetManifestOptions>,
    ) -> Result<WrapManifest, polywrap_core::error::Error> {
        let encoded_manifest = match self.manifest.clone() {
            Some(manifest) => manifest,
            None => self.file_reader.read_file("wrap.info")?,
        };

        let opts = options.map(|options| DeserializeManifestOptions {
            no_validate: options.no_validate,
            ext_schema: None,
        });
        let deserialized_manifest = deserialize_wrap_manifest(&encoded_manifest, opts)
            .map_err(|e| polywrap_core::error::Error::ManifestError(e.to_string()))?;

        Ok(deserialized_manifest)
    }

    fn create_wrapper(&self) -> Result<Arc<dyn Wrapper>, polywrap_core::error::Error> {
        let wasm_bytes = self.get_wasm_module()?;

        let mut wasm_module = self.wasm_module.lock().unwrap();

        let compiled_module = if wasm_module.is_some() {
            wasm_module.clone().unwrap().compile()?
        } else {
            CompiledWasmModule::try_from_bytecode(&wasm_bytes)?
        };

        *wasm_module = Some(WasmModule::Compiled(compiled_module.clone()));

        return Ok(Arc::new(WasmWrapper::new(
            compiled_module,
            self.file_reader.clone(),
        )));
    }
}