@hpcc-js/comms 2.102.1 → 2.102.2

package/src/ecl/timer.ts

@@ -1,42 +1,42 @@
-import { espTime2Seconds, StateObject } from "@hpcc-js/util";
-import { IConnection, IOptions } from "../connection";
-import { WorkunitsService, WsWorkunits } from "../services/wsWorkunits";
-
-export interface ECLTimerEx extends WsWorkunits.ECLTimer {
-    Wuid: string;
-    Seconds: number;
-    HasSubGraphId: boolean;
-}
-
-export class Timer extends StateObject<ECLTimerEx, ECLTimerEx> implements ECLTimerEx {
-    protected connection: WorkunitsService;
-
-    get properties(): WsWorkunits.ECLTimer { return this.get(); }
-    get Wuid(): string { return this.get("Wuid"); }
-    get Name(): string { return this.get("Name"); }
-    get Value(): string { return this.get("Value"); }
-    get Seconds(): number { return this.get("Seconds"); }
-    get GraphName(): string { return this.get("GraphName"); }
-    get SubGraphId(): number { return this.get("SubGraphId"); }
-    get HasSubGraphId(): boolean { return this.get("HasSubGraphId"); }
-    get count(): number { return this.get("count"); }
-    get Timestamp(): number { return this.get("Timestamp"); }
-    get When(): string { return this.get("When"); }
-
-    constructor(optsConnection: IOptions | IConnection | WorkunitsService, wuid: string, eclTimer: WsWorkunits.ECLTimer) {
-        super();
-        if (optsConnection instanceof WorkunitsService) {
-            this.connection = optsConnection;
-        } else {
-            this.connection = new WorkunitsService(optsConnection);
-        }
-
-        const secs = espTime2Seconds(eclTimer.Value);
-        this.set({
-            Wuid: wuid,
-            Seconds: Math.round(secs * 1000) / 1000,
-            HasSubGraphId: eclTimer.SubGraphId !== undefined,
-            ...eclTimer
-        });
-    }
-}
+import { espTime2Seconds, StateObject } from "@hpcc-js/util";
+import { IConnection, IOptions } from "../connection";
+import { WorkunitsService, WsWorkunits } from "../services/wsWorkunits";
+
+export interface ECLTimerEx extends WsWorkunits.ECLTimer {
+    Wuid: string;
+    Seconds: number;
+    HasSubGraphId: boolean;
+}
+
+export class Timer extends StateObject<ECLTimerEx, ECLTimerEx> implements ECLTimerEx {
+    protected connection: WorkunitsService;
+
+    get properties(): WsWorkunits.ECLTimer { return this.get(); }
+    get Wuid(): string { return this.get("Wuid"); }
+    get Name(): string { return this.get("Name"); }
+    get Value(): string { return this.get("Value"); }
+    get Seconds(): number { return this.get("Seconds"); }
+    get GraphName(): string { return this.get("GraphName"); }
+    get SubGraphId(): number { return this.get("SubGraphId"); }
+    get HasSubGraphId(): boolean { return this.get("HasSubGraphId"); }
+    get count(): number { return this.get("count"); }
+    get Timestamp(): number { return this.get("Timestamp"); }
+    get When(): string { return this.get("When"); }
+
+    constructor(optsConnection: IOptions | IConnection | WorkunitsService, wuid: string, eclTimer: WsWorkunits.ECLTimer) {
+        super();
+        if (optsConnection instanceof WorkunitsService) {
+            this.connection = optsConnection;
+        } else {
+            this.connection = new WorkunitsService(optsConnection);
+        }
+
+        const secs = espTime2Seconds(eclTimer.Value);
+        this.set({
+            Wuid: wuid,
+            Seconds: Math.round(secs * 1000) / 1000,
+            HasSubGraphId: eclTimer.SubGraphId !== undefined,
+            ...eclTimer
+        });
+    }
+}

package/src/ecl/topology.ts

@@ -1,131 +1,131 @@
-import { Cache, exists, StateCallback, StateEvents, StateObject, StatePropCallback } from "@hpcc-js/util";
-import { IConnection, IOptions } from "../connection";
-import { TopologyService, WsTopology } from "../services/wsTopology";
-import { TargetCluster } from "./targetCluster";
-
-export class TopologyCache extends Cache<{ BaseUrl: string }, Topology> {
-    constructor() {
-        super((obj) => {
-            return obj.BaseUrl;
-        });
-    }
-}
-const _topology = new TopologyCache();
-
-export interface TopologyStateEx {
-    TargetClusters?: WsTopology.TpTargetCluster[];
-    LogicalClusters?: WsTopology.TpLogicalCluster[];
-    Services?: WsTopology.ServiceList;
-}
-export class Topology extends StateObject<TopologyStateEx, TopologyStateEx> implements TopologyStateEx {
-    protected connection: TopologyService;
-    get BaseUrl() { return this.connection.baseUrl; }
-
-    //  Accessors  ---
-    get properties(): TopologyStateEx { return this.get(); }
-    get TargetClusters(): WsTopology.TpTargetCluster[] { return this.get("TargetClusters"); }
-    get CTargetClusters(): TargetCluster[] {
-        return this.TargetClusters.map(tc => TargetCluster.attach(this.connection, tc.Name, tc));
-    }
-    get LogicalClusters(): WsTopology.TpLogicalCluster[] { return this.get("LogicalClusters"); }
-    get Services(): WsTopology.ServiceList { return this.get("Services"); }
-
-    static attach(optsConnection: IOptions | IConnection | TopologyService, state?: TopologyStateEx): Topology {
-        const retVal: Topology = _topology.get({ BaseUrl: optsConnection.baseUrl }, () => {
-            return new Topology(optsConnection);
-        });
-        if (state) {
-            retVal.set(state);
-        }
-        return retVal;
-    }
-
-    protected constructor(optsConnection: IOptions | IConnection | TopologyService) {
-        super();
-        if (optsConnection instanceof TopologyService) {
-            this.connection = optsConnection;
-        } else {
-            this.connection = new TopologyService(optsConnection);
-        }
-    }
-
-    GetESPServiceBaseURL(type: string = ""): Promise<string> {
-        return this.connection.TpServiceQuery({}).then(response => {
-            const rootProtocol = this.connection.protocol();
-            const ip = this.connection.ip();
-            let port = rootProtocol === "https:" ? "18002" : "8002";
-            if (exists("ServiceList.TpEspServers.TpEspServer", response)) {
-                for (const item of response.ServiceList.TpEspServers.TpEspServer) {
-                    if (exists("TpBindings.TpBinding", item)) {
-                        for (const binding of item.TpBindings.TpBinding) {
-                            if (binding.Service === type && binding.Protocol + ":" === rootProtocol) {
-                                port = binding.Port;
-                            }
-                        }
-                    }
-                }
-            }
-            return `${rootProtocol}//${ip}:${port}/`;
-        });
-    }
-
-    fetchTargetClusters(): Promise<TargetCluster[]> {
-        return this.connection.TpTargetClusterQuery({ Type: "ROOT" }).then(response => {
-            this.set({
-                TargetClusters: response.TpTargetClusters?.TpTargetCluster ?? []
-            });
-            return this.CTargetClusters;
-        });
-    }
-
-    fetchLogicalClusters(request: WsTopology.TpLogicalClusterQueryRequest = {}): Promise<WsTopology.TpLogicalCluster[]> {
-        return this.connection.TpLogicalClusterQuery(request).then(response => {
-            this.set({
-                LogicalClusters: response.TpLogicalClusters.TpLogicalCluster
-            });
-            return this.LogicalClusters;
-        });
-    }
-
-    fetchServices(request: WsTopology.TpServiceQueryRequest = {}): Promise<WsTopology.ServiceList> {
-        return this.connection.TpServiceQuery(request).then(response => {
-            this.set({
-                Services: response.ServiceList
-            });
-            return this.Services;
-        });
-    }
-
-    protected _prevRefresh;
-    refresh(force: boolean = false): Promise<this> {
-        if (!this._prevRefresh || force) {
-            this._prevRefresh = Promise.all([this.fetchTargetClusters(), this.fetchLogicalClusters(), this.fetchServices()]).then(() => {
-                return this;
-            });
-        }
-        return this._prevRefresh;
-    }
-
-    //  Monitoring  ---
-
-    //  Events  ---
-    on(eventID: StateEvents, propIDorCallback: StateCallback | keyof TopologyStateEx, callback?: StatePropCallback): this {
-        if (this.isCallback(propIDorCallback)) {
-            switch (eventID) {
-                case "changed":
-                    super.on(eventID, propIDorCallback);
-                    break;
-                default:
-            }
-        } else {
-            switch (eventID) {
-                case "changed":
-                    super.on(eventID, propIDorCallback, callback!);
-                    break;
-                default:
-            }
-        }
-        this._monitor();
-        return this;
-    }
-}
+import { Cache, exists, StateCallback, StateEvents, StateObject, StatePropCallback } from "@hpcc-js/util";
+import { IConnection, IOptions } from "../connection";
+import { TopologyService, WsTopology } from "../services/wsTopology";
+import { TargetCluster } from "./targetCluster";
+
+export class TopologyCache extends Cache<{ BaseUrl: string }, Topology> {
+    constructor() {
+        super((obj) => {
+            return obj.BaseUrl;
+        });
+    }
+}
+const _topology = new TopologyCache();
+
+export interface TopologyStateEx {
+    TargetClusters?: WsTopology.TpTargetCluster[];
+    LogicalClusters?: WsTopology.TpLogicalCluster[];
+    Services?: WsTopology.ServiceList;
+}
+export class Topology extends StateObject<TopologyStateEx, TopologyStateEx> implements TopologyStateEx {
+    protected connection: TopologyService;
+    get BaseUrl() { return this.connection.baseUrl; }
+
+    //  Accessors  ---
+    get properties(): TopologyStateEx { return this.get(); }
+    get TargetClusters(): WsTopology.TpTargetCluster[] { return this.get("TargetClusters"); }
+    get CTargetClusters(): TargetCluster[] {
+        return this.TargetClusters.map(tc => TargetCluster.attach(this.connection, tc.Name, tc));
+    }
+    get LogicalClusters(): WsTopology.TpLogicalCluster[] { return this.get("LogicalClusters"); }
+    get Services(): WsTopology.ServiceList { return this.get("Services"); }
+
+    static attach(optsConnection: IOptions | IConnection | TopologyService, state?: TopologyStateEx): Topology {
+        const retVal: Topology = _topology.get({ BaseUrl: optsConnection.baseUrl }, () => {
+            return new Topology(optsConnection);
+        });
+        if (state) {
+            retVal.set(state);
+        }
+        return retVal;
+    }
+
+    protected constructor(optsConnection: IOptions | IConnection | TopologyService) {
+        super();
+        if (optsConnection instanceof TopologyService) {
+            this.connection = optsConnection;
+        } else {
+            this.connection = new TopologyService(optsConnection);
+        }
+    }
+
+    GetESPServiceBaseURL(type: string = ""): Promise<string> {
+        return this.connection.TpServiceQuery({}).then(response => {
+            const rootProtocol = this.connection.protocol();
+            const ip = this.connection.ip();
+            let port = rootProtocol === "https:" ? "18002" : "8002";
+            if (exists("ServiceList.TpEspServers.TpEspServer", response)) {
+                for (const item of response.ServiceList.TpEspServers.TpEspServer) {
+                    if (exists("TpBindings.TpBinding", item)) {
+                        for (const binding of item.TpBindings.TpBinding) {
+                            if (binding.Service === type && binding.Protocol + ":" === rootProtocol) {
+                                port = binding.Port;
+                            }
+                        }
+                    }
+                }
+            }
+            return `${rootProtocol}//${ip}:${port}/`;
+        });
+    }
+
+    fetchTargetClusters(): Promise<TargetCluster[]> {
+        return this.connection.TpTargetClusterQuery({ Type: "ROOT" }).then(response => {
+            this.set({
+                TargetClusters: response.TpTargetClusters?.TpTargetCluster ?? []
+            });
+            return this.CTargetClusters;
+        });
+    }
+
+    fetchLogicalClusters(request: WsTopology.TpLogicalClusterQueryRequest = {}): Promise<WsTopology.TpLogicalCluster[]> {
+        return this.connection.TpLogicalClusterQuery(request).then(response => {
+            this.set({
+                LogicalClusters: response.TpLogicalClusters.TpLogicalCluster
+            });
+            return this.LogicalClusters;
+        });
+    }
+
+    fetchServices(request: WsTopology.TpServiceQueryRequest = {}): Promise<WsTopology.ServiceList> {
+        return this.connection.TpServiceQuery(request).then(response => {
+            this.set({
+                Services: response.ServiceList
+            });
+            return this.Services;
+        });
+    }
+
+    protected _prevRefresh;
+    refresh(force: boolean = false): Promise<this> {
+        if (!this._prevRefresh || force) {
+            this._prevRefresh = Promise.all([this.fetchTargetClusters(), this.fetchLogicalClusters(), this.fetchServices()]).then(() => {
+                return this;
+            });
+        }
+        return this._prevRefresh;
+    }
+
+    //  Monitoring  ---
+
+    //  Events  ---
+    on(eventID: StateEvents, propIDorCallback: StateCallback | keyof TopologyStateEx, callback?: StatePropCallback): this {
+        if (this.isCallback(propIDorCallback)) {
+            switch (eventID) {
+                case "changed":
+                    super.on(eventID, propIDorCallback);
+                    break;
+                default:
+            }
+        } else {
+            switch (eventID) {
+                case "changed":
+                    super.on(eventID, propIDorCallback, callback!);
+                    break;
+                default:
+            }
+        }
+        this._monitor();
+        return this;
+    }
+}