pulumi_gestalt_rust_adapter_wasm/
runner.rs

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
use crate::WasmContext;
use anyhow::{Context, Error, Result};
use log::{error, info};
use pulumi_gestalt_wit::client_bindings::component::pulumi_gestalt::stack_interface::{
    FunctionInvocationRequest, FunctionInvocationResult,
};

pub fn run<F>(in_preview_u8: u8, f: F) -> Result<(), Error>
where
    F: Fn(&WasmContext) -> Result<(), Error>,
{
    let in_preview = in_preview_u8 == 1;
    let main = || {
        let context = WasmContext::new(in_preview);
        pulumi_gestalt_rust_common::setup_logger();
        f(&context)?;
        run_loop(&context)?;
        Ok(())
    };

    let result = main();

    match result {
        Ok(()) => Ok(()),
        Err(e) => {
            error!("Error running pulumi wasm: [{e}]");
            Err(e)
        }
    }
}

fn run_loop(context: &WasmContext) -> Result<(), Error> {
    run_all_function(context)
}

fn run_all_function(context: &WasmContext) -> Result<(), Error> {
    let mut functions = context.invoke_finish(vec![])?;

    loop {
        if functions.is_empty() {
            return Ok(());
        }
        let mapped = map_functions(context, &functions)?;
        functions = context.invoke_finish(mapped)?;
    }
}

fn map_functions<'a>(
    context: &'a WasmContext,
    functions: &'a [FunctionInvocationRequest],
) -> Result<Vec<FunctionInvocationResult<'a>>> {
    functions
        .iter()
        .map(
            |FunctionInvocationRequest {
                 id,
                 function_id,
                 value,
             }| {
                info!("Invoking function [{function_id}] with value [{value:?}]");
                let result = context
                    .invoke_function(function_id, value)
                    .with_context(|| format!("Error invoking function [{function_id}]"))?;
                Ok(FunctionInvocationResult { id, value: result })
            },
        )
        .collect()
}