Add support progress event

application/apps/protocol/binding/wasm/src/msg/mod.rs

@@ -5,4 +5,5 @@ pub mod error;
 pub mod event;
 pub mod grabbing;
 pub mod observe;
+pub mod progress;
 pub mod sde;

application/apps/protocol/binding/wasm/src/msg/progress.rs

@@ -0,0 +1,17 @@
+use crate::*;
+use extend::extend;
+use prost::Message;
+use serde_wasm_bindgen::{from_value, to_value};
+use wasm_bindgen::prelude::*;
+
+#[extend(progress)]
+pub struct Ticks;
+
+#[extend(progress)]
+pub struct LifecycleTransition;
+
+#[extend(progress)]
+pub struct Started;
+
+#[extend(progress)]
+pub struct TicksWithUuid;

application/apps/rustcore/ts-bindings/spec/session.protocol.spec.ts

@@ -59,27 +59,51 @@ describe('Protocol', function () {
                 .then((session: Session) => {
                     // Set provider into debug mode
                     session.debug(true);
-                    const MESSAGES_COUNT = 100000;
-                    const meausere: { json: number; proto: number } = { json: 0, proto: 0 };
-                    meausere.json = Date.now();
-                    for (let i = MESSAGES_COUNT; i >= 0; i -= 1) {
-                        const msg = session.getNativeSession().testGrabElsAsJson();
-                        expect(msg instanceof Array).toBe(true);
+                    const MESSAGES_COUNT = 100;
+                    {
+                        const meausere: { json: number; proto: number } = { json: 0, proto: 0 };
+                        meausere.json = Date.now();
+                        for (let i = MESSAGES_COUNT; i >= 0; i -= 1) {
+                            const msg = session.getNativeSession().testGrabElsAsJson(false);
+                            expect(msg instanceof Array).toBe(true);
+                        }
+                        meausere.json = Date.now() - meausere.json;
+                        meausere.proto = Date.now();
+                        for (let i = MESSAGES_COUNT; i >= 0; i -= 1) {
+                            const msg = session.getNativeSession().testGrabElsAsProto(false);
+                            expect(msg instanceof Array).toBe(true);
+                        }
+                        meausere.proto = Date.now() - meausere.proto;
+                        console.log(
+                            `Receiving messages count: ${MESSAGES_COUNT}\nJSON: ${
+                                meausere.json
+                            }ms (per msg ${(meausere.json / MESSAGES_COUNT).toFixed(2)});\nPROTO: ${
+                                meausere.proto
+                            }ms (per msg ${(meausere.proto / MESSAGES_COUNT).toFixed(2)})`,
+                        );
                     }
-                    meausere.json = Date.now() - meausere.json;
-                    meausere.proto = Date.now();
-                    for (let i = MESSAGES_COUNT; i >= 0; i -= 1) {
-                        const msg = session.getNativeSession().testGrabElsAsProto();
-                        expect(msg instanceof Array).toBe(true);
+                    {
+                        const meausere: { json: number; proto: number } = { json: 0, proto: 0 };
+                        meausere.json = Date.now();
+                        for (let i = MESSAGES_COUNT; i >= 0; i -= 1) {
+                            const msg = session.getNativeSession().testGrabElsAsJson();
+                            expect(msg instanceof Array).toBe(true);
+                        }
+                        meausere.json = Date.now() - meausere.json;
+                        meausere.proto = Date.now();
+                        for (let i = MESSAGES_COUNT; i >= 0; i -= 1) {
+                            const msg = session.getNativeSession().testGrabElsAsProto();
+                            expect(msg instanceof Array).toBe(true);
+                        }
+                        meausere.proto = Date.now() - meausere.proto;
+                        console.log(
+                            `Grabbing messages count: ${MESSAGES_COUNT}\nJSON: ${
+                                meausere.json
+                            }ms (per msg ${(meausere.json / MESSAGES_COUNT).toFixed(2)});\nPROTO: ${
+                                meausere.proto
+                            }ms (per msg ${(meausere.proto / MESSAGES_COUNT).toFixed(2)})`,
+                        );
                     }
-                    meausere.proto = Date.now() - meausere.proto;
-                    console.log(
-                        `Grabbing messages count: ${MESSAGES_COUNT}\nJSON: ${
-                            meausere.json
-                        }ms (per msg ${(meausere.json / MESSAGES_COUNT).toFixed(2)});\nPROTO: ${
-                            meausere.proto
-                        }ms (per msg ${(meausere.proto / MESSAGES_COUNT).toFixed(2)})`,
-                    );
                     finish(session, done);
                 })
                 .catch((err: Error) => {

application/apps/rustcore/ts-bindings/src/api/session.provider.ts

@@ -5,6 +5,8 @@ import { EErrorKind, EErrorSeverity } from '../provider/provider.errors';
 import { IMapEntity, IMatchEntity, IValuesMinMaxMap } from 'platform/types/filter';
 import { IAttachment } from 'platform/types/content';
 
+import * as Types from '../protocol';
+
 export interface IProgressState {
     total: number;
     count: number;
@@ -194,7 +196,7 @@ export class EventProvider extends Computation<
     private readonly _convertors: ISessionEventsConvertors = {};
 
     constructor(uuid: string) {
-        super(uuid);
+        super(uuid, Types.decodeCallbackEvent);
     }
 
     public getName(): string {

application/apps/rustcore/ts-bindings/src/api/tracker.provider.ts

@@ -1,6 +1,8 @@
 import { Subject } from 'platform/env/subscription';
 import { Computation } from '../provider/provider';
 
+import * as Types from '../protocol';
+
 export interface Job {
     alias: string;
     uuid: string;
@@ -74,7 +76,7 @@ export class EventProvider extends Computation<
     private readonly _convertors = {};
 
     constructor(uuid: string) {
-        super(uuid);
+        super(uuid, Types.decodeLifecycleTransition);
     }
 
     public getName(): string {

application/apps/rustcore/ts-bindings/src/native/native.session.ts

@@ -204,10 +204,10 @@ export abstract class RustSession extends RustSessionRequiered {
     public abstract triggerTrackerError(): Promise<void>;
 
     // Used only for testing and debug
-    public abstract testGrabElsAsJson(): IGrabbedElement[] | NativeError;
+    public abstract testGrabElsAsJson(decode?: boolean): IGrabbedElement[] | NativeError;
 
     // Used only for testing and debug
-    public abstract testGrabElsAsProto(): IGrabbedElement[] | NativeError;
+    public abstract testGrabElsAsProto(decode?: boolean): IGrabbedElement[] | NativeError;
 }
 
 export abstract class RustSessionNative {
@@ -879,8 +879,12 @@ export class RustSessionWrapper extends RustSession {
     }
 
     // Used only for testing and debug
-    public testGrabElsAsJson(): IGrabbedElement[] | NativeError {
+    public testGrabElsAsJson(decode?: boolean): IGrabbedElement[] | NativeError {
         try {
+            const received = this._native.testGrabElsAsJson();
+            if (decode === false) {
+                return [];
+            }
             const lines: Array<{
                 c: string;
                 id: number;
@@ -911,9 +915,13 @@ export class RustSessionWrapper extends RustSession {
     }
 
     // Used only for testing and debug
-    public testGrabElsAsProto(): IGrabbedElement[] | NativeError {
+    public testGrabElsAsProto(decode?: boolean): IGrabbedElement[] | NativeError {
         try {
-            return Types.decodeGrabbedElementList(this._native.testGrabElsAsProto());
+            const received = this._native.testGrabElsAsProto();
+            if (decode === false) {
+                return [];
+            }
+            return Types.decodeGrabbedElementList(received);
         } catch (err) {
             return new NativeError(new Error(utils.error(err)), Type.Other, Source.Other);
         }

application/apps/rustcore/ts-bindings/src/protocol/Transition.ts

@@ -1,6 +1,6 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
-import type { Started } from "./Started";
-import type { Stopped } from "./Stopped";
-import type { TicksWithUuid } from "./TicksWithUuid";
+import type { Started } from './Started';
+import type { Stopped } from './Stopped';
+import type { TicksWithUuid } from './TicksWithUuid';
 
-export type Transition = { "Started": Started } | { "Ticks": TicksWithUuid } | { "Stopped": Stopped };
+export type Transition = { Started: Started } | { Ticks: TicksWithUuid } | { Stopped: Stopped };

application/apps/rustcore/ts-bindings/src/protocol/index.ts

@@ -287,6 +287,35 @@ export function toObserveOptions(source: IObserve): ObserveOptions {
     return { origin: { origin }, parser };
 }
 
+export function decodeLifecycleTransition(buf: number[]): any {
+    const event: LifecycleTransition = proto.LifecycleTransition.decode(Uint8Array.from(buf));
+    if (!event.transition) {
+        return {};
+    }
+    const inner: Transition = event.transition;
+    if ('Started' in inner) {
+        return { Started: { uuid: inner.Started.uuid, alias: inner.Started.alias } };
+    } else if ('Ticks' in inner) {
+        const ticks = inner.Ticks.ticks;
+        return {
+            Ticks: {
+                uuid: inner.Ticks.uuid,
+                progress:
+                    ticks === null
+                        ? {}
+                        : {
+                              count: Number(ticks.count),
+                              state: ticks.state,
+                              total: Number(ticks.total),
+                          },
+            },
+        };
+    } else if ('Stopped' in inner) {
+        return { Stopped: inner.Stopped.uuid };
+    } else {
+        throw new Error(`Fail to parse event: ${JSON.stringify(event)}`);
+    }
+}
 export function decodeCallbackEvent(buf: number[]): any {
     const event: CallbackEvent = proto.CallbackEvent.decode(Uint8Array.from(buf));
     if (!event.event) {

application/apps/rustcore/ts-bindings/src/provider/provider.ts

@@ -9,18 +9,20 @@ import { Logger } from 'platform/log';
 import { scope } from 'platform/env/scope';
 import { TEventData, TEventEmitter, IEventData } from '../provider/provider.general';
 
-import * as Types from '../protocol';
-
 export interface IOrderStat {
     type: 'E' | 'O';
     name: string;
     id: string | undefined;
     emitted: number; // Time of emitting event or operation
     duration: number;
 }
+
+export type Decoder = (buf: number[]) => any;
+
 export abstract class Computation<TEvents, IEventsSignatures, IEventsInterfaces> {
     private _destroyed: boolean = false;
     private readonly _uuid: string;
+    private readonly _decoder: Decoder;
     private readonly _tracking: {
         subjects: {
             unsupported: Subject<string>;
@@ -56,8 +58,9 @@ export abstract class Computation<TEvents, IEventsSignatures, IEventsInterfaces>
     };
     public readonly logger: Logger;
 
-    constructor(uuid: string) {
+    constructor(uuid: string, decoder: Decoder) {
         this._uuid = uuid;
+        this._decoder = decoder;
         this._emitter = this._emitter.bind(this);
         this.logger = scope.getLogger(`${this.getName()}: ${uuid}`);
     }
@@ -252,7 +255,7 @@ export abstract class Computation<TEvents, IEventsSignatures, IEventsInterfaces>
         let event: Required<IEventData>;
         try {
             if (data instanceof Array) {
-                event = Types.decodeCallbackEvent(data);
+                event = this._decoder(data);
             } else if (typeof data === 'string') {
                 try {
                     event = JSON.parse(data);