Merge branch 'main' into integration-test

providers/pulumi_wasm_provider_random_rust/src/random.rs

@@ -23,7 +23,6 @@ fn random_to_domain_mapper<F: serde::Serialize>(random: pulumi_provider_random_i
     unsafe {
         let inner = random.take_handle();
         Output::<F>::new_from_handle(inner)
-        // output_interface::Output::from_handle(inner)
     }
 }
 

pulumi_wasm/src/output.rs

@@ -11,9 +11,6 @@ impl FunctionId {
     pub(crate) fn from_string(s: &String) -> FunctionId {
         FunctionId(s.to_string())
     }
-    pub(crate) fn from_str(s: &str) -> FunctionId {
-        FunctionId(s.to_string())
-    }
     pub(crate) fn get(&self) -> String {
         self.0.clone()
     }
@@ -55,11 +52,6 @@ pub(crate) fn access_map() -> &'static mut Vec<OutputContentRefCell> {
     // unsafe { &mut GLOBAL_MAP }
 }
 
-struct Output {
-    content: OutputContent,
-    tags: Vec<String>,
-}
-
 pub(crate) enum OutputContent {
     Done(Value),
     Mapped(FunctionId, FunctionSource, OutputContentRefCell),

pulumi_wasm_runner/src/main.rs

@@ -81,8 +81,8 @@ async fn main() -> Result<(), Error> {
                     eprintln!("Cannot specify both wasm and cwasm");
                     std::process::exit(1);
                 }
-                (Some(wasm), None) => WasmFile::WASM(wasm.clone()),
-                (None, Some(cwasm)) => WasmFile::CWASM(cwasm.clone()),
+                (Some(wasm), None) => WasmFile::Wasm(wasm.clone()),
+                (None, Some(cwasm)) => WasmFile::CompiledWasm(cwasm.clone()),
                 (None, None) => {
                     eprintln!("Must specify either wasm or cwasm");
                     std::process::exit(1);
@@ -92,7 +92,7 @@ async fn main() -> Result<(), Error> {
             let _pulumi_engine_url = std::env::var("PULUMI_ENGINE")?;
             let pulumi_monitor_url = std::env::var("PULUMI_MONITOR")?;
 
-            let pulumi = Pulumi::create(&wasm, &Some(pulumi_monitor_url)).await?;
+            let mut pulumi = Pulumi::create(&wasm, &Some(pulumi_monitor_url)).await?;
             pulumi.start().await?;
         }
         Command::Compile { wasm, output } => {

pulumi_wasm_runner/src/pulumi.rs

@@ -1,7 +1,3 @@
-use std::cell::RefCell;
-use std::ops::DerefMut;
-use std::rc::Rc;
-
 use anyhow::Error;
 use async_trait::async_trait;
 use prost::Message;
@@ -16,7 +12,7 @@ use crate::pulumi::server::Main;
 pub struct Pulumi {
     plugin: Main,
     _instance: Instance,
-    store: RefCell<Store<SimplePluginCtx>>,
+    store: Store<SimplePluginCtx>,
 }
 
 pub(crate) mod server {
@@ -101,15 +97,15 @@ impl WasiView for SimplePluginCtx {
 }
 
 pub enum WasmFile {
-    WASM(String),
-    CWASM(String),
+    Wasm(String),
+    CompiledWasm(String),
 }
 
 impl Pulumi {
     pub async fn create(
         pulumi_wasm_file: &WasmFile,
         pulumi_monitor_url: &Option<String>,
-    ) -> Result<Rc<Pulumi>, Error> {
+    ) -> Result<Pulumi, Error> {
         let mut engine_config = wasmtime::Config::new();
         engine_config.wasm_component_model(true);
         engine_config.async_support(true);
@@ -145,8 +141,8 @@ impl Pulumi {
         );
 
         let component = match pulumi_wasm_file {
-            WasmFile::WASM(file) => Component::from_file(&engine, file),
-            WasmFile::CWASM(file) => {
+            WasmFile::Wasm(file) => Component::from_file(&engine, file),
+            WasmFile::CompiledWasm(file) => {
                 unsafe {
                     Component::deserialize_file(&engine, file)
                 }
@@ -155,13 +151,11 @@ impl Pulumi {
 
         let (plugin, instance) = Main::instantiate_async(&mut store, &component, &linker).await?;
 
-        let store = RefCell::new(store);
-
-        Ok(Rc::new(Pulumi {
+        Ok(Pulumi {
             plugin,
             _instance: instance,
             store,
-        }))
+        })
     }
 
     pub fn compile(pulumi_wasm_file: &String) -> Result<Vec<u8>, Error> {
@@ -185,12 +179,10 @@ impl Pulumi {
         component.serialize()
     }
 
-    pub async fn start(&self) -> Result<(), Error> {
-        let mut binding = self.store.borrow_mut();
-        let store = binding.deref_mut();
+    pub async fn start(&mut self) -> Result<(), Error> {
         self.plugin
             .component_pulumi_wasm_pulumi_main()
-            .call_main(store)
+            .call_main(&mut self.store)
             .await?;
 
         Ok(())

pulumi_wasm_rust/src/lib.rs

@@ -110,8 +110,10 @@ fn run_all_function(
 
 pub mod output;
 
+type Function = Box<dyn Fn(Vec<u8>) -> Result<Vec<u8>, Error> + Send>;
+
 lazy_static! {
-    pub static ref HASHMAP: Mutex<HashMap<String, Box<dyn Fn(Vec<u8>) -> Result<Vec<u8>, anyhow::Error> + Send>>> = {
+    pub static ref HASHMAP: Mutex<HashMap<String, Function>> = {
         let m = HashMap::new();
         Mutex::new(m)
     };

pulumi_wasm_rust/src/output.rs

@@ -17,10 +17,19 @@ impl <T: serde::Serialize> From<T> for Output<T> {
 
 impl<T> Output<T> {
 
+    ///
+    /// # Safety
+    ///
+    /// Returns handle to inner output representation. Only needed in provider glue code.
     pub unsafe fn get_inner(&self) -> &output_interface::Output {
         &self.future
     }
 
+    ///
+    /// # Safety
+    ///
+    /// Underlying output type must the same as `F` and this Output will take ownership of the handle.
+    /// This means that the handle must not be deallocated by something else.
     pub unsafe fn new_from_handle<F: serde::Serialize>(handle: u32) -> Output<F> {
         let output = output_interface::Output::from_handle(handle);
         Output {