Add event parsing example

landonxjames · Aug 9, 2023 · 77d98fe · 77d98fe
1 parent 6a00fcf
commit 77d98fe
Show file tree

Hide file tree

Showing 9 changed files with 434 additions and 8 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -32,6 +32,8 @@ tower = "0.4.13"
 http = "0.2.9"
 wit-bindgen = { version = "0.9.0" }
 tokio = {version = "1.29.1", features = ["macros", "rt"]}
+serde_json = "1.0.104"
+serde = {version = "1.0.183", features = ["derive"]}
 
 [lib]
 crate-type = ["cdylib"]
diff --git a/jsbind/act-utils.d.ts b/jsbind/act-utils.d.ts
@@ -2,4 +2,6 @@ import { CredsClient } from './interfaces/creds-client';
 import { HttpClient } from './interfaces/http-client';
 import { PrintClient } from './interfaces/print-client';
 import { TimeClient } from './interfaces/time-client';
+import { ActUtilsAlarmConnectorDef } from './interfaces/act-utils-alarm-connector-def';
+export const alarmConnectorDef: typeof ActUtilsAlarmConnectorDef;
 export function listTables(): string;
diff --git a/jsbind/act-utils.mjs b/jsbind/act-utils.mjs
@@ -168,6 +168,113 @@ function lowering3(arg0) {
 }
 let exports2;
 let postReturn0;
+let postReturn1;
+
+function parse(arg0) {
+  const ptr0 = utf8Encode(arg0, realloc0, memory0);
+  const len0 = utf8EncodedLen;
+  const ret = exports1['act:utils/alarm-connector-def#parse'](ptr0, len0);
+  let variant16;
+  switch (dataView(memory0).getUint8(ret + 0, true)) {
+    case 0: {
+      const ptr1 = dataView(memory0).getInt32(ret + 4, true);
+      const len1 = dataView(memory0).getInt32(ret + 8, true);
+      const result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+      const ptr2 = dataView(memory0).getInt32(ret + 12, true);
+      const len2 = dataView(memory0).getInt32(ret + 16, true);
+      const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+      const ptr3 = dataView(memory0).getInt32(ret + 20, true);
+      const len3 = dataView(memory0).getInt32(ret + 24, true);
+      const result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+      const ptr4 = dataView(memory0).getInt32(ret + 28, true);
+      const len4 = dataView(memory0).getInt32(ret + 32, true);
+      const result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+      const ptr5 = dataView(memory0).getInt32(ret + 36, true);
+      const len5 = dataView(memory0).getInt32(ret + 40, true);
+      const result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+      const ptr6 = dataView(memory0).getInt32(ret + 44, true);
+      const len6 = dataView(memory0).getInt32(ret + 48, true);
+      const result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+      const len9 = dataView(memory0).getInt32(ret + 56, true);
+      const base9 = dataView(memory0).getInt32(ret + 52, true);
+      const result9 = [];
+      for (let i = 0; i < len9; i++) {
+        const base = base9 + i * 16;
+        const ptr7 = dataView(memory0).getInt32(base + 0, true);
+        const len7 = dataView(memory0).getInt32(base + 4, true);
+        const result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
+        const ptr8 = dataView(memory0).getInt32(base + 8, true);
+        const len8 = dataView(memory0).getInt32(base + 12, true);
+        const result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+        result9.push({
+          language: result7,
+          latestDescription: result8,
+        });
+      }
+      const len14 = dataView(memory0).getInt32(ret + 64, true);
+      const base14 = dataView(memory0).getInt32(ret + 60, true);
+      const result14 = [];
+      for (let i = 0; i < len14; i++) {
+        const base = base14 + i * 16;
+        const ptr10 = dataView(memory0).getInt32(base + 0, true);
+        const len10 = dataView(memory0).getInt32(base + 4, true);
+        const result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+        const len13 = dataView(memory0).getInt32(base + 12, true);
+        const base13 = dataView(memory0).getInt32(base + 8, true);
+        const result13 = [];
+        for (let i = 0; i < len13; i++) {
+          const base = base13 + i * 16;
+          const ptr11 = dataView(memory0).getInt32(base + 0, true);
+          const len11 = dataView(memory0).getInt32(base + 4, true);
+          const result11 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr11, len11));
+          const ptr12 = dataView(memory0).getInt32(base + 8, true);
+          const len12 = dataView(memory0).getInt32(base + 12, true);
+          const result12 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr12, len12));
+          result13.push({
+            key: result11,
+            value: result12,
+          });
+        }
+        result14.push({
+          entityValue: result10,
+          tags: result13,
+        });
+      }
+      variant16= {
+        tag: 'ok',
+        val: {
+          eventArn: result1,
+          service: result2,
+          eventTypeCode: result3,
+          eventTypeCategory: result4,
+          startTime: result5,
+          endTime: result6,
+          eventDescription: result9,
+          affectedEntities: result14,
+        }
+      };
+      break;
+    }
+    case 1: {
+      const ptr15 = dataView(memory0).getInt32(ret + 4, true);
+      const len15 = dataView(memory0).getInt32(ret + 8, true);
+      const result15 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr15, len15));
+      variant16= {
+        tag: 'err',
+        val: result15
+      };
+      break;
+    }
+    default: {
+      throw new TypeError('invalid variant discriminant for expected');
+    }
+  }
+  postReturn0(ret);
+  if (variant16.tag === 'err') {
+    throw new ComponentError(variant16.val);
+  }
+  return variant16.val;
+}
 
 function listTables() {
   const ret = exports1['list-tables']();
@@ -197,7 +304,7 @@ function listTables() {
       throw new TypeError('invalid variant discriminant for expected');
     }
   }
-  postReturn0(ret);
+  postReturn1(ret);
   if (variant2.tag === 'err') {
     throw new ComponentError(variant2.val);
   }
@@ -234,9 +341,14 @@ const $init = (async() => {
       '2': lowering3,
     },
   }));
-  postReturn0 = exports1['cabi_post_list-tables'];
+  postReturn0 = exports1['cabi_post_act:utils/alarm-connector-def#parse'];
+  postReturn1 = exports1['cabi_post_list-tables'];
 })();
 
 await $init;
+const alarmConnectorDef = {
+  parse: parse,
+
+};
 
-export { listTables }
+export { alarmConnectorDef, alarmConnectorDef as 'act:utils/alarm-connector-def', listTables }
diff --git a/jsbind/interfaces/act-utils-alarm-connector-def.d.ts b/jsbind/interfaces/act-utils-alarm-connector-def.d.ts
@@ -0,0 +1,27 @@
+export namespace ActUtilsAlarmConnectorDef {
+  export function parse(input: string): AlarmEvent;
+}
+export interface EventDescription {
+  language: string,
+  latestDescription: string,
+}
+export type EventDescList = EventDescription[];
+export interface Tag {
+  key: string,
+  value: string,
+}
+export interface Entity {
+  entityValue: string,
+  tags: Tag[],
+}
+export type EntityList = Entity[];
+export interface AlarmEvent {
+  eventArn: string,
+  service: string,
+  eventTypeCode: string,
+  eventTypeCategory: string,
+  startTime: string,
+  endTime: string,
+  eventDescription: EventDescList,
+  affectedEntities: EntityList,
+}
diff --git a/pybind/__init__.py b/pybind/__init__.py
@@ -1,3 +1,4 @@
+from .exports import alarm_connector_def
 from .imports import RootImports, http_client
 from .intrinsics import _clamp, _decode_utf8, _encode_utf8, _list_canon_lift, _list_canon_lower, _load, _store
 from .types import Err, Ok, Result
@@ -96,14 +97,20 @@ def lowering3_callee(caller: wasmtime.Caller, arg0: int) -> None:
             lowering3,
             instance0["$imports"],
         ]).exports(store)
-        post_return0 = instance1["cabi_post_list-tables"]
+        post_return0 = instance1["cabi_post_act:utils/alarm-connector-def#parse"]
         assert(isinstance(post_return0, wasmtime.Func))
         self._post_return0 = post_return0
-        lift_callee0 = instance1["list-tables"]
+        post_return1 = instance1["cabi_post_list-tables"]
+        assert(isinstance(post_return1, wasmtime.Func))
+        self._post_return1 = post_return1
+        lift_callee0 = instance1["act:utils/alarm-connector-def#parse"]
         assert(isinstance(lift_callee0, wasmtime.Func))
         self.lift_callee0 = lift_callee0
+        lift_callee1 = instance1["list-tables"]
+        assert(isinstance(lift_callee1, wasmtime.Func))
+        self.lift_callee1 = lift_callee1
     def list_tables(self, caller: wasmtime.Store) -> Result[str, str]:
-        ret = self.lift_callee0(caller)
+        ret = self.lift_callee1(caller)
         assert(isinstance(ret, int))
         load = _load(ctypes.c_uint8, self._core_memory0, caller, ret, 0)
         expected: Result[str, str]
@@ -123,5 +130,7 @@ def list_tables(self, caller: wasmtime.Store) -> Result[str, str]:
             expected = Err(list7)
         else:
             raise TypeError("invalid variant discriminant for expected")
-        self._post_return0(caller, ret)
+        self._post_return1(caller, ret)
         return expected
+    def alarm_connector_def(self) -> alarm_connector_def.AlarmConnectorDef:
+        return alarm_connector_def.AlarmConnectorDef(self)
diff --git a/pybind/exports/__init__.py b/pybind/exports/__init__.py
diff --git a/pybind/exports/alarm_connector_def.py b/pybind/exports/alarm_connector_def.py
@@ -0,0 +1,142 @@
+from ..intrinsics import _decode_utf8, _encode_utf8, _load
+from ..types import Err, Ok, Result
+import ctypes
+from dataclasses import dataclass
+from typing import List
+import wasmtime
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+  from .. import Root
+
+@dataclass
+class EventDescription:
+    language: str
+    latest_description: str
+
+EventDescList = List[EventDescription]
+@dataclass
+class Tag:
+    key: str
+    value: str
+
+@dataclass
+class Entity:
+    entity_value: str
+    tags: List[Tag]
+
+EntityList = List[Entity]
+@dataclass
+class AlarmEvent:
+    event_arn: str
+    service: str
+    event_type_code: str
+    event_type_category: str
+    start_time: str
+    end_time: str
+    event_description: EventDescList
+    affected_entities: EntityList
+
+class AlarmConnectorDef:
+    component: 'Root'
+
+    def __init__(self, component: 'Root') -> None:
+        self.component = component
+    def parse(self, caller: wasmtime.Store, input: str) -> Result[AlarmEvent, str]:
+        ptr, len0 = _encode_utf8(input, self.component._realloc0, self.component._core_memory0, caller)
+        ret = self.component.lift_callee0(caller, ptr, len0)
+        assert(isinstance(ret, int))
+        load = _load(ctypes.c_uint8, self.component._core_memory0, caller, ret, 0)
+        expected: Result[AlarmEvent, str]
+        if load == 0:
+            load1 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4)
+            load2 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 8)
+            ptr3 = load1
+            len4 = load2
+            list = _decode_utf8(self.component._core_memory0, caller, ptr3, len4)
+            load5 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 12)
+            load6 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 16)
+            ptr7 = load5
+            len8 = load6
+            list9 = _decode_utf8(self.component._core_memory0, caller, ptr7, len8)
+            load10 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 20)
+            load11 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 24)
+            ptr12 = load10
+            len13 = load11
+            list14 = _decode_utf8(self.component._core_memory0, caller, ptr12, len13)
+            load15 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 28)
+            load16 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 32)
+            ptr17 = load15
+            len18 = load16
+            list19 = _decode_utf8(self.component._core_memory0, caller, ptr17, len18)
+            load20 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 36)
+            load21 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 40)
+            ptr22 = load20
+            len23 = load21
+            list24 = _decode_utf8(self.component._core_memory0, caller, ptr22, len23)
+            load25 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 44)
+            load26 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 48)
+            ptr27 = load25
+            len28 = load26
+            list29 = _decode_utf8(self.component._core_memory0, caller, ptr27, len28)
+            load30 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 52)
+            load31 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 56)
+            ptr43 = load30
+            len44 = load31
+            result: List[EventDescription] = []
+            for i45 in range(0, len44):
+                base32 = ptr43 + i45 * 16
+                load33 = _load(ctypes.c_int32, self.component._core_memory0, caller, base32, 0)
+                load34 = _load(ctypes.c_int32, self.component._core_memory0, caller, base32, 4)
+                ptr35 = load33
+                len36 = load34
+                list37 = _decode_utf8(self.component._core_memory0, caller, ptr35, len36)
+                load38 = _load(ctypes.c_int32, self.component._core_memory0, caller, base32, 8)
+                load39 = _load(ctypes.c_int32, self.component._core_memory0, caller, base32, 12)
+                ptr40 = load38
+                len41 = load39
+                list42 = _decode_utf8(self.component._core_memory0, caller, ptr40, len41)
+                result.append(EventDescription(list37, list42))
+            load46 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 60)
+            load47 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 64)
+            ptr71 = load46
+            len72 = load47
+            result73: List[Entity] = []
+            for i74 in range(0, len72):
+                base48 = ptr71 + i74 * 16
+                load49 = _load(ctypes.c_int32, self.component._core_memory0, caller, base48, 0)
+                load50 = _load(ctypes.c_int32, self.component._core_memory0, caller, base48, 4)
+                ptr51 = load49
+                len52 = load50
+                list53 = _decode_utf8(self.component._core_memory0, caller, ptr51, len52)
+                load54 = _load(ctypes.c_int32, self.component._core_memory0, caller, base48, 8)
+                load55 = _load(ctypes.c_int32, self.component._core_memory0, caller, base48, 12)
+                ptr67 = load54
+                len68 = load55
+                result69: List[Tag] = []
+                for i70 in range(0, len68):
+                    base56 = ptr67 + i70 * 16
+                    load57 = _load(ctypes.c_int32, self.component._core_memory0, caller, base56, 0)
+                    load58 = _load(ctypes.c_int32, self.component._core_memory0, caller, base56, 4)
+                    ptr59 = load57
+                    len60 = load58
+                    list61 = _decode_utf8(self.component._core_memory0, caller, ptr59, len60)
+                    load62 = _load(ctypes.c_int32, self.component._core_memory0, caller, base56, 8)
+                    load63 = _load(ctypes.c_int32, self.component._core_memory0, caller, base56, 12)
+                    ptr64 = load62
+                    len65 = load63
+                    list66 = _decode_utf8(self.component._core_memory0, caller, ptr64, len65)
+                    result69.append(Tag(list61, list66))
+                result73.append(Entity(list53, result69))
+            expected = Ok(AlarmEvent(list, list9, list14, list19, list24, list29, result, result73))
+        elif load == 1:
+            load75 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 4)
+            load76 = _load(ctypes.c_int32, self.component._core_memory0, caller, ret, 8)
+            ptr77 = load75
+            len78 = load76
+            list79 = _decode_utf8(self.component._core_memory0, caller, ptr77, len78)
+            expected = Err(list79)
+        else:
+            raise TypeError("invalid variant discriminant for expected")
+        self.component._post_return0(caller, ret)
+        return expected