WIP: Implemented BigDecimal for combining numbers

Author: FranklinWaller

examples/simple-url-call/Cargo.lock

@@ -13,4 +13,5 @@ opt-level = 'z'
 [dependencies]
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
-jsonpath-rust = "0.1.0"
+jsonpath-rust = "0.1.0"
+bigdecimal = "0.3.0"

examples/simple-url-call/Cargo.toml

@@ -1,4 +1,5 @@
 use std::str;
+use std::process;
 use serde::Deserialize;
 use serde_json::{ json, from_str };
 use std::collections::HashMap;
@@ -83,3 +84,24 @@ pub fn http_call(url: &str, options: Option<HttpCallOptions>) -> Result<CallResu
         result: parsed_result.result,
     });
 }
+
+pub enum Outcome {
+    Invalid,
+    Valid(String)
+}
+
+pub fn exit_with_outcome(outcome: &Outcome) {
+    let result = match outcome {
+        Outcome::Invalid => json!({ "type": "Invalid" }).to_string(),
+        Outcome::Valid(answer) => json!({ "type": "Valid", "value": answer }).to_string(),
+    };
+
+    let exit_code = match outcome {
+        Outcome::Invalid => 1,
+        Outcome::Valid(_) => 0,
+    };
+    
+    // Make sure we don't interfene with other logs by adding \n
+    print!("\n{}", result);
+    process::exit(exit_code);
+}

examples/simple-url-call/src/flux/mod.rs

@@ -1,30 +1,85 @@
 use std::env;
-use std::collections::HashMap;
+use serde::{ Deserialize, Serialize };
 use jsonpath_rust::JsonPathFinder;
+use bigdecimal::{ BigDecimal };
+use std::str::{ FromStr };
+use std::ops::{ Add, Div, Mul };
 
 mod flux;
 
+#[derive(Serialize, Deserialize, Debug)]
+struct Source {
+    end_point: String,
+    source_path: String,
+}
+
 fn main() {
     let args: Vec<String> = env::args().collect();
-    let mut headers: HashMap<String, String> = HashMap::new();
+    let sources: Vec<Source> = serde_json::from_str(args.get(1).unwrap()).unwrap();
+    let sources_type = args.get(2).unwrap();
+    let mut string_result: String = "".to_string();
+    let mut number_result = BigDecimal::from(0);
+    let mut used_sources: u32 = 0;
+
+    assert_ne!(sources.len(), 0, "ERR_NO_SOURCES");
+
+    if sources_type == "string" {
+        assert_eq!(sources.len(), 1, "ERR_TOO_MUCH_SOURCES");
+    } else if sources_type == "number" {
+        assert!(args.get(3).is_some(), "ERR_NO_MULTIPLIER");
+    } else {
+        panic!("ERR_UNSUPPORTED_TYPE");
+    }
+
+    for source in sources.iter() {
+        let http_result = flux::http_call(&source.end_point, None);
+
+        if http_result.is_err() {
+            eprintln!("{}", http_result.unwrap_err().error);
+            continue;
+        }
+
+        let http_result_data = http_result.unwrap().result;
+        
+        // Finds a value in the returned json using the path given in args
+        let finder = JsonPathFinder::from_str(&http_result_data, &source.source_path).unwrap();
+        let found_values = finder.find();
+        let result_value = found_values.get(0).unwrap();
+
+        if sources_type == "string" {
+            string_result = result_value.as_str().unwrap().to_string();
+        } else if sources_type == "number" {
+            // Converting numbers to strings so we can use BigDecimal to combine them all
+            let mut val: Option<BigDecimal> = None;
+
+            if result_value.is_i64() {
+                val = Some(BigDecimal::from(result_value.as_i64().unwrap()));
+            } else if result_value.is_string() {
+                // strings can still be valid numbers
+                val = Some(BigDecimal::from_str(result_value.as_str().unwrap()).unwrap());
+            } else if result_value.is_u64() {
+                val = Some(BigDecimal::from(result_value.as_u64().unwrap()));
+            } else if result_value.is_f64() {
+                val = Some(BigDecimal::from_str(&result_value.as_f64().unwrap().to_string()).unwrap());
+            }
+
+            number_result = number_result.add(val.unwrap());
+        }
 
-    headers.insert("Content-Type".to_string(), "json".to_string());
+        used_sources += 1;
+    }
 
-    let http_result = flux::http_call(args.get(1).unwrap(), Some(flux::HttpCallOptions {
-        headers: Some(headers),
-        body: None,
-        method: Some("GET".to_string()),
-    }));
+    assert_ne!(used_sources, 0, "ERR_FAILING_SOURCES");
 
-    let response = match http_result {
-        Ok(data) => data,
-        Err(error) => panic!("Status: {}, Error: {}", error.status, error.error),
-    };
+    if sources_type == "string" {
+        flux::exit_with_outcome(&flux::Outcome::Valid(string_result));
+    } else if sources_type == "number" {
+        let multiplier = BigDecimal::from_str(args.get(3).unwrap()).unwrap();
 
-    let finder = JsonPathFinder::from_str(&response.result, args.get(2).unwrap());
-    let unwrapped_finder = finder.unwrap();
-    let finder_values = unwrapped_finder.find();
-    let final_value = finder_values.get(0).unwrap();
+        number_result = number_result.div(BigDecimal::from(used_sources));
+        number_result = number_result.mul(multiplier);
+        number_result = number_result.round(0);
 
-    print!("{}", final_value.as_str().unwrap());
+        flux::exit_with_outcome(&flux::Outcome::Valid(number_result.to_string()));
+    }
 }

examples/simple-url-call/src/main.rs

@@ -5,6 +5,7 @@ import { URL as NodeURL } from "url";
 import { extractMessageFromEvent } from './services/WorkerService';
 import { MessageType, RequestMessage } from './models/WorkerMessage';
 import ProcessMethods from './ProcessMethods';
+import { ExecuteResult } from './models/ExecuteResult';
 
 export default class Process extends EventEmitter {
     public context: Context;
@@ -44,4 +45,16 @@ export default class Process extends EventEmitter {
 
         worker.postMessage(spawnMessage);
     }
+}
+
+export function execute(context: Context): Promise<ExecuteResult> {
+    return new Promise((resolve) => {
+        const process = new Process(context);
+        
+        process.on('exit', (result: ExecuteResult) => {
+            resolve(result);
+        });
+
+        process.spawn();
+    });
 }

src/Process.ts

@@ -18,52 +18,62 @@ export function prepareWasmBinary(binary: Uint8Array): Uint8Array {
     return meteredWasm;
 }
 
-export async function executeWasm(context: VmContext): Promise<ExecuteResult> {
-    const wasmFs = new WasmFs();
-    const virtualFs = new VirtualFs(wasmFs);
-    
-    try {
-        const random = alea(context.randomSeed);
-        const wasi = new WASI({
-            args: context.args,
-            env: context.env,
-            bindings: {
-                ...WASIBindings,
-                fs: virtualFs.getFs(),
-                hrtime: () => BigInt(context.timestamp),
-                randomFillSync: (buffer: any, offset, size) => {
-                    const randomBuffer = generateFixedBuffer(random.int32().toString(), size ?? buffer.length - offset);
-                    buffer.set(randomBuffer, offset);
-                    return buffer;
+export function executeWasm(context: VmContext): Promise<ExecuteResult> {
+    return new Promise(async (resolve) => {
+        const wasmFs = new WasmFs();
+        const virtualFs = new VirtualFs(wasmFs);
+        
+        try {
+            const random = alea(context.randomSeed);
+            const wasi = new WASI({
+                args: context.args,
+                env: context.env,
+                bindings: {
+                    ...WASIBindings,
+                    fs: virtualFs.getFs(),
+                    hrtime: () => BigInt(context.timestamp),
+                    randomFillSync: (buffer: any, offset, size) => {
+                        const randomBuffer = generateFixedBuffer(random.int32().toString(), size ?? buffer.length - offset);
+                        buffer.set(randomBuffer, offset);
+                        return buffer;
+                    },
+                    exit: (rval: number) => {
+                        resolve({
+                            code: rval,
+                            gasUsed: context.gasUsed.toString(),
+                            logs: virtualFs.getLogOutput(),
+                        });
+                    },
                 },
-            },
-        });
-
-        const preparedBinary = prepareWasmBinary(context.binary);
-        const module = await WebAssembly.compile(preparedBinary.buffer);
-        const wasiImports = wasi.getImports(module);
-        const wasmImports = new WasmImports(context, wasiImports);
-        const instance = await WebAssembly.instantiate(module, wasmImports.getImports());
-
-        wasmImports.setMemory(instance.exports.memory as WebAssembly.Memory);
-        wasi.start(instance);
+            });
+    
+            const preparedBinary = prepareWasmBinary(context.binary);
+            const module = await WebAssembly.compile(preparedBinary.buffer);
+            const wasiImports = wasi.getImports(module);
+            const wasmImports = new WasmImports(context, wasiImports);
+            const instance = await WebAssembly.instantiate(module, wasmImports.getImports());
+    
+            wasmImports.setMemory(instance.exports.memory as WebAssembly.Memory);
+            wasi.start(instance);
+        
+            resolve({
+                code: 0,
+                logs: virtualFs.getLogOutput(),
+                gasUsed: context.gasUsed.toString(),
+            });
+        } catch(error: any) {
+            const logs = virtualFs.getLogOutput();
 
-        const logs = virtualFs.getLogOutput();
+            // Runtime errors should be handled by logs
+            if (!(error instanceof WebAssembly.RuntimeError)) {
+                logs.push(error?.message);
+            }
 
-        return {
-            code: 0,
-            logs,
-            gasUsed: context.gasUsed.toString(),
+            resolve({
+                code: error?.code ?? 1,
+                logs,
+                gasUsed: context.gasUsed.toString(),
+            });
         }
-    } catch(error: any) {
-        const logs = virtualFs.getLogOutput();
-
-        logs.push(error?.message);
-
-        return {
-            code: error?.code ?? 1,
-            logs,
-            gasUsed: context.gasUsed.toString(),
-        };
-    }
+    });
 }