@hpcc-js/comms 2.102.1 → 2.102.2

package/src/ecl/store.ts

@@ -1,154 +1,154 @@
-import { Cache, Dispatch, IObserverHandle, Message } from "@hpcc-js/util";
-import { IConnection, IOptions } from "../connection";
-import { StoreService } from "../services/wsStore";
-
-export class StoreCache extends Cache<{ BaseUrl: string, Name: string, UserSpecific: boolean, Namespace: string }, Store> {
-    constructor() {
-        super((obj) => {
-            return `${obj.BaseUrl}-${obj.Name}:${obj.UserSpecific}-${obj.Namespace}`;
-        });
-    }
-}
-const _store = new StoreCache();
-
-export class ValueChangedMessage extends Message {
-
-    constructor(readonly key: string, public value: any, public oldValue?: any) {
-        super();
-    }
-
-    get canConflate(): boolean { return true; }
-    conflate(other: ValueChangedMessage): boolean {
-        if (this.key === other.key) {
-            this.value = other.value;
-            return true;
-        }
-        return false;
-    }
-
-    void(): boolean {
-        return this.value === this.oldValue;
-    }
-}
-
-export class Store {
-    protected connection: StoreService;
-    get BaseUrl() { return this.connection.baseUrl; }
-    readonly Name: string;
-    readonly UserSpecific: boolean;
-    readonly Namespace: string;
-
-    protected _dispatch = new Dispatch();
-
-    static attach(optsConnection: IOptions | IConnection | StoreService, Name: string = "HPCCApps", Namespace: string, UserSpecific: boolean = true): Store {
-        const retVal: Store = _store.get({ BaseUrl: optsConnection.baseUrl, Name, UserSpecific, Namespace }, () => {
-            return new Store(optsConnection, Name, Namespace, UserSpecific);
-        });
-        return retVal;
-    }
-
-    protected constructor(optsConnection: IOptions | IConnection | StoreService, Name: string, Namespace: string, UserSpecific: boolean) {
-        if (optsConnection instanceof StoreService) {
-            this.connection = optsConnection;
-        } else {
-            this.connection = new StoreService(optsConnection);
-        }
-        this.Name = Name;
-        this.UserSpecific = UserSpecific;
-        this.Namespace = Namespace;
-    }
-
-    private _knownValues: { [key: string]: any } = {};
-
-    protected create() {
-        this.connection.CreateStore({ Name: this.Name, UserSpecific: this.UserSpecific, Type: "", Description: "" });
-    }
-
-    set(key: string, value: string, broadcast = true): Promise<void> {
-        return this.connection.Set({
-            StoreName: this.Name,
-            UserSpecific: this.UserSpecific,
-            Namespace: this.Namespace,
-            Key: key,
-            Value: value
-        }).then(response => {
-            const oldValue = this._knownValues[key];
-            this._knownValues[key] = value;
-            if (broadcast) {
-                this._dispatch.post(new ValueChangedMessage(key, value, oldValue));
-            }
-        }).catch(e => {
-            console.error(`Store.set("${key}", "${value}") failed:`, e);
-        });
-    }
-
-    get(key: string, broadcast = true): Promise<string | undefined> {
-        return this.connection.Fetch({
-            StoreName: this.Name,
-            UserSpecific: this.UserSpecific,
-            Namespace: this.Namespace,
-            Key: key
-        }).then(response => {
-            const oldValue = this._knownValues[key];
-            this._knownValues[key] = response.Value;
-            if (broadcast) {
-                this._dispatch.post(new ValueChangedMessage(key, response.Value, oldValue));
-            }
-            return response.Value;
-        }).catch(e => {
-            console.error(`Store.get(${key}) failed:`, e);
-            return undefined;
-        });
-    }
-
-    getAll(broadcast = true): Promise<{ [key: string]: string }> {
-        return this.connection.FetchAll({
-            StoreName: this.Name,
-            UserSpecific: this.UserSpecific,
-            Namespace: this.Namespace
-        }).then(response => {
-            const retVal: { [key: string]: string } = {};
-            const deletedValues = this._knownValues;
-            this._knownValues = {};
-            response.Pairs.Pair.forEach(pair => {
-                const oldValue = this._knownValues[pair.Key];
-                this._knownValues[pair.Key] = pair.Value;
-                delete deletedValues[pair.Key];
-                retVal[pair.Key] = pair.Value;
-                if (broadcast) {
-                    this._dispatch.post(new ValueChangedMessage(pair.Key, pair.Value, oldValue));
-                }
-            });
-            if (broadcast) {
-                for (const key in deletedValues) {
-                    this._dispatch.post(new ValueChangedMessage(key, undefined, deletedValues[key]));
-                }
-            }
-            return retVal;
-        }).catch(e => {
-            console.error("Store.getAll failed:", e);
-            return {};
-        });
-    }
-
-    delete(key: string, broadcast = true): Promise<void> {
-        return this.connection.Delete({
-            StoreName: this.Name,
-            UserSpecific: this.UserSpecific,
-            Namespace: this.Namespace,
-            Key: key
-        }).then(response => {
-            const oldValue = this._knownValues[key];
-            delete this._knownValues[key];
-            if (broadcast) {
-                this._dispatch.post(new ValueChangedMessage(key, undefined, oldValue));
-            }
-        }).catch(e => {
-            console.error(`Store.delete(${key}) failed:`, e);
-        });
-    }
-
-    monitor(callback: (messages: ValueChangedMessage[]) => void): IObserverHandle {
-        return this._dispatch.attach(callback);
-    }
-}
+import { Cache, Dispatch, IObserverHandle, Message } from "@hpcc-js/util";
+import { IConnection, IOptions } from "../connection";
+import { StoreService } from "../services/wsStore";
+
+export class StoreCache extends Cache<{ BaseUrl: string, Name: string, UserSpecific: boolean, Namespace: string }, Store> {
+    constructor() {
+        super((obj) => {
+            return `${obj.BaseUrl}-${obj.Name}:${obj.UserSpecific}-${obj.Namespace}`;
+        });
+    }
+}
+const _store = new StoreCache();
+
+export class ValueChangedMessage extends Message {
+
+    constructor(readonly key: string, public value: any, public oldValue?: any) {
+        super();
+    }
+
+    get canConflate(): boolean { return true; }
+    conflate(other: ValueChangedMessage): boolean {
+        if (this.key === other.key) {
+            this.value = other.value;
+            return true;
+        }
+        return false;
+    }
+
+    void(): boolean {
+        return this.value === this.oldValue;
+    }
+}
+
+export class Store {
+    protected connection: StoreService;
+    get BaseUrl() { return this.connection.baseUrl; }
+    readonly Name: string;
+    readonly UserSpecific: boolean;
+    readonly Namespace: string;
+
+    protected _dispatch = new Dispatch();
+
+    static attach(optsConnection: IOptions | IConnection | StoreService, Name: string = "HPCCApps", Namespace: string, UserSpecific: boolean = true): Store {
+        const retVal: Store = _store.get({ BaseUrl: optsConnection.baseUrl, Name, UserSpecific, Namespace }, () => {
+            return new Store(optsConnection, Name, Namespace, UserSpecific);
+        });
+        return retVal;
+    }
+
+    protected constructor(optsConnection: IOptions | IConnection | StoreService, Name: string, Namespace: string, UserSpecific: boolean) {
+        if (optsConnection instanceof StoreService) {
+            this.connection = optsConnection;
+        } else {
+            this.connection = new StoreService(optsConnection);
+        }
+        this.Name = Name;
+        this.UserSpecific = UserSpecific;
+        this.Namespace = Namespace;
+    }
+
+    private _knownValues: { [key: string]: any } = {};
+
+    protected create() {
+        this.connection.CreateStore({ Name: this.Name, UserSpecific: this.UserSpecific, Type: "", Description: "" });
+    }
+
+    set(key: string, value: string, broadcast = true): Promise<void> {
+        return this.connection.Set({
+            StoreName: this.Name,
+            UserSpecific: this.UserSpecific,
+            Namespace: this.Namespace,
+            Key: key,
+            Value: value
+        }).then(response => {
+            const oldValue = this._knownValues[key];
+            this._knownValues[key] = value;
+            if (broadcast) {
+                this._dispatch.post(new ValueChangedMessage(key, value, oldValue));
+            }
+        }).catch(e => {
+            console.error(`Store.set("${key}", "${value}") failed:`, e);
+        });
+    }
+
+    get(key: string, broadcast = true): Promise<string | undefined> {
+        return this.connection.Fetch({
+            StoreName: this.Name,
+            UserSpecific: this.UserSpecific,
+            Namespace: this.Namespace,
+            Key: key
+        }).then(response => {
+            const oldValue = this._knownValues[key];
+            this._knownValues[key] = response.Value;
+            if (broadcast) {
+                this._dispatch.post(new ValueChangedMessage(key, response.Value, oldValue));
+            }
+            return response.Value;
+        }).catch(e => {
+            console.error(`Store.get(${key}) failed:`, e);
+            return undefined;
+        });
+    }
+
+    getAll(broadcast = true): Promise<{ [key: string]: string }> {
+        return this.connection.FetchAll({
+            StoreName: this.Name,
+            UserSpecific: this.UserSpecific,
+            Namespace: this.Namespace
+        }).then(response => {
+            const retVal: { [key: string]: string } = {};
+            const deletedValues = this._knownValues;
+            this._knownValues = {};
+            response.Pairs.Pair.forEach(pair => {
+                const oldValue = this._knownValues[pair.Key];
+                this._knownValues[pair.Key] = pair.Value;
+                delete deletedValues[pair.Key];
+                retVal[pair.Key] = pair.Value;
+                if (broadcast) {
+                    this._dispatch.post(new ValueChangedMessage(pair.Key, pair.Value, oldValue));
+                }
+            });
+            if (broadcast) {
+                for (const key in deletedValues) {
+                    this._dispatch.post(new ValueChangedMessage(key, undefined, deletedValues[key]));
+                }
+            }
+            return retVal;
+        }).catch(e => {
+            console.error("Store.getAll failed:", e);
+            return {};
+        });
+    }
+
+    delete(key: string, broadcast = true): Promise<void> {
+        return this.connection.Delete({
+            StoreName: this.Name,
+            UserSpecific: this.UserSpecific,
+            Namespace: this.Namespace,
+            Key: key
+        }).then(response => {
+            const oldValue = this._knownValues[key];
+            delete this._knownValues[key];
+            if (broadcast) {
+                this._dispatch.post(new ValueChangedMessage(key, undefined, oldValue));
+            }
+        }).catch(e => {
+            console.error(`Store.delete(${key}) failed:`, e);
+        });
+    }
+
+    monitor(callback: (messages: ValueChangedMessage[]) => void): IObserverHandle {
+        return this._dispatch.attach(callback);
+    }
+}

package/src/ecl/targetCluster.ts

@@ -1,149 +1,149 @@
-import { Cache, StateObject } from "@hpcc-js/util";
-import { IConnection, IOptions } from "../connection";
-import { WsMachine, WsMachineEx, MachineService } from "../services/wsMachine";
-import { TopologyService, WsTopology } from "../services/wsTopology";
-import { Machine } from "./machine";
-
-export class TargetClusterCache extends Cache<{ BaseUrl: string, Name: string }, TargetCluster> {
-    constructor() {
-        super((obj) => {
-            return `${obj.BaseUrl}-${obj.Name}`;
-        });
-    }
-}
-const _targetCluster = new TargetClusterCache();
-
-export interface TpTargetClusterEx {
-    MachineInfoEx: WsMachine.MachineInfoEx[];
-}
-
-export type UTargetClusterState = WsTopology.TpTargetCluster & WsTopology.TpClusterNameType & TpTargetClusterEx;
-export type ITargetClusterState = WsTopology.TpTargetCluster | WsTopology.TpClusterNameType | TpTargetClusterEx;
-export class TargetCluster extends StateObject<UTargetClusterState, ITargetClusterState> implements UTargetClusterState {
-    protected connection: TopologyService;
-    protected machineConnection: MachineService;
-    get BaseUrl() { return this.connection.baseUrl; }
-
-    get Name(): string { return this.get("Name"); }
-    get Prefix(): string { return this.get("Prefix"); }
-    get Type(): string { return this.get("Type"); }
-    get IsDefault(): boolean { return this.get("IsDefault"); }
-    get TpClusters(): WsTopology.TpClusters { return this.get("TpClusters"); }
-    get TpEclCCServers(): WsTopology.TpEclCCServers { return this.get("TpEclCCServers"); }
-    get TpEclServers(): WsTopology.TpEclServers { return this.get("TpEclServers"); }
-    get TpEclAgents(): WsTopology.TpEclAgents { return this.get("TpEclAgents"); }
-    get TpEclSchedulers(): WsTopology.TpEclSchedulers { return this.get("TpEclSchedulers"); }
-    get MachineInfoEx(): WsMachine.MachineInfoEx[] { return this.get("MachineInfoEx", []); }
-    get CMachineInfoEx(): Machine[] {
-        return this.MachineInfoEx.map(machineInfoEx => Machine.attach(this.machineConnection, machineInfoEx.Address, machineInfoEx));
-    }
-
-    static attach(optsConnection: IOptions | IConnection | TopologyService, name: string, state?: ITargetClusterState): TargetCluster {
-        const retVal: TargetCluster = _targetCluster.get({ BaseUrl: optsConnection.baseUrl, Name: name }, () => {
-            return new TargetCluster(optsConnection, name);
-        });
-        if (state) {
-            retVal.set(state);
-        }
-        return retVal;
-    }
-
-    protected constructor(optsConnection: IOptions | IConnection | TopologyService, name: string) {
-        super();
-        if (optsConnection instanceof TopologyService) {
-            this.connection = optsConnection;
-            this.machineConnection = new MachineService(optsConnection.connectionOptions());
-        } else {
-            this.connection = new TopologyService(optsConnection);
-            this.machineConnection = new MachineService(optsConnection);
-        }
-        this.clear({
-            Name: name
-        });
-    }
-
-    fetchMachines(request: WsMachine.GetTargetClusterInfoRequest = {}): Promise<Machine[]> {
-        return this.machineConnection.GetTargetClusterInfo({
-            TargetClusters: {
-                Item: [`${this.Type}:${this.Name}`]
-            },
-            ...request
-        }).then(response => {
-            const retVal: WsMachine.MachineInfoEx[] = [];
-            for (const machineInfo of response.TargetClusterInfoList.TargetClusterInfo) {
-                for (const machineInfoEx of machineInfo.Processes.MachineInfoEx) {
-                    retVal.push(machineInfoEx);
-                }
-            }
-            this.set("MachineInfoEx", retVal);
-            return this.CMachineInfoEx;
-        });
-    }
-
-    machineStats(): { maxDisk: number; meanDisk: number } {
-        let maxDisk = 0;
-        let totalFree = 0;
-        let total = 0;
-        for (const machine of this.CMachineInfoEx) {
-            for (const storageInfo of machine.Storage.StorageInfo) {
-                totalFree += storageInfo.Available;
-                total += storageInfo.Total;
-                const usage = 1 - storageInfo.Available / storageInfo.Total;
-                if (usage > maxDisk) {
-                    maxDisk = usage;
-                }
-            }
-        }
-        return {
-            maxDisk,
-            meanDisk: 1 - (total ? totalFree / total : 1)
-        };
-    }
-
-    fetchUsage(): Promise<WsMachineEx.TargetClusterUsage[]> {
-        return this.machineConnection.GetTargetClusterUsageEx([this.Name]);
-    }
-}
-
-export function targetClusters(optsConnection: IOptions | IConnection | TopologyService): Promise<TargetCluster[]> {
-    let connection: TopologyService;
-    if (optsConnection instanceof TopologyService) {
-        connection = optsConnection;
-    } else {
-        connection = new TopologyService(optsConnection);
-    }
-    return connection.TpListTargetClusters({}).then(response => {
-        return response.TargetClusters.TpClusterNameType.map(item => TargetCluster.attach(optsConnection, item.Name, item));
-    });
-}
-
-const _defaultTargetCluster: { [baseUrl: string]: Promise<TargetCluster> } = {};
-export function defaultTargetCluster(optsConnection: IOptions | IConnection | TopologyService): Promise<TargetCluster> {
-    if (!_defaultTargetCluster[optsConnection.baseUrl]) {
-        let connection: TopologyService;
-        if (optsConnection instanceof TopologyService) {
-            connection = optsConnection;
-        } else {
-            connection = new TopologyService(optsConnection);
-        }
-        _defaultTargetCluster[optsConnection.baseUrl] = connection.TpListTargetClusters({}).then(response => {
-            let firstItem: WsTopology.TpClusterNameType;
-            let defaultItem: WsTopology.TpClusterNameType;
-            let hthorItem: WsTopology.TpClusterNameType;
-            response.TargetClusters.TpClusterNameType.forEach(item => {
-                if (!firstItem) {
-                    firstItem = item;
-                }
-                if (!defaultItem && item.IsDefault === true) {
-                    defaultItem = item;
-                }
-                if (!hthorItem && item.Type === "hthor") {
-                    hthorItem = item;
-                }
-            });
-            const defItem = defaultItem || hthorItem || firstItem;
-            return TargetCluster.attach(optsConnection, defItem.Name, defItem);
-        });
-    }
-    return _defaultTargetCluster[optsConnection.baseUrl];
-}
+import { Cache, StateObject } from "@hpcc-js/util";
+import { IConnection, IOptions } from "../connection";
+import { WsMachine, WsMachineEx, MachineService } from "../services/wsMachine";
+import { TopologyService, WsTopology } from "../services/wsTopology";
+import { Machine } from "./machine";
+
+export class TargetClusterCache extends Cache<{ BaseUrl: string, Name: string }, TargetCluster> {
+    constructor() {
+        super((obj) => {
+            return `${obj.BaseUrl}-${obj.Name}`;
+        });
+    }
+}
+const _targetCluster = new TargetClusterCache();
+
+export interface TpTargetClusterEx {
+    MachineInfoEx: WsMachine.MachineInfoEx[];
+}
+
+export type UTargetClusterState = WsTopology.TpTargetCluster & WsTopology.TpClusterNameType & TpTargetClusterEx;
+export type ITargetClusterState = WsTopology.TpTargetCluster | WsTopology.TpClusterNameType | TpTargetClusterEx;
+export class TargetCluster extends StateObject<UTargetClusterState, ITargetClusterState> implements UTargetClusterState {
+    protected connection: TopologyService;
+    protected machineConnection: MachineService;
+    get BaseUrl() { return this.connection.baseUrl; }
+
+    get Name(): string { return this.get("Name"); }
+    get Prefix(): string { return this.get("Prefix"); }
+    get Type(): string { return this.get("Type"); }
+    get IsDefault(): boolean { return this.get("IsDefault"); }
+    get TpClusters(): WsTopology.TpClusters { return this.get("TpClusters"); }
+    get TpEclCCServers(): WsTopology.TpEclCCServers { return this.get("TpEclCCServers"); }
+    get TpEclServers(): WsTopology.TpEclServers { return this.get("TpEclServers"); }
+    get TpEclAgents(): WsTopology.TpEclAgents { return this.get("TpEclAgents"); }
+    get TpEclSchedulers(): WsTopology.TpEclSchedulers { return this.get("TpEclSchedulers"); }
+    get MachineInfoEx(): WsMachine.MachineInfoEx[] { return this.get("MachineInfoEx", []); }
+    get CMachineInfoEx(): Machine[] {
+        return this.MachineInfoEx.map(machineInfoEx => Machine.attach(this.machineConnection, machineInfoEx.Address, machineInfoEx));
+    }
+
+    static attach(optsConnection: IOptions | IConnection | TopologyService, name: string, state?: ITargetClusterState): TargetCluster {
+        const retVal: TargetCluster = _targetCluster.get({ BaseUrl: optsConnection.baseUrl, Name: name }, () => {
+            return new TargetCluster(optsConnection, name);
+        });
+        if (state) {
+            retVal.set(state);
+        }
+        return retVal;
+    }
+
+    protected constructor(optsConnection: IOptions | IConnection | TopologyService, name: string) {
+        super();
+        if (optsConnection instanceof TopologyService) {
+            this.connection = optsConnection;
+            this.machineConnection = new MachineService(optsConnection.connectionOptions());
+        } else {
+            this.connection = new TopologyService(optsConnection);
+            this.machineConnection = new MachineService(optsConnection);
+        }
+        this.clear({
+            Name: name
+        });
+    }
+
+    fetchMachines(request: WsMachine.GetTargetClusterInfoRequest = {}): Promise<Machine[]> {
+        return this.machineConnection.GetTargetClusterInfo({
+            TargetClusters: {
+                Item: [`${this.Type}:${this.Name}`]
+            },
+            ...request
+        }).then(response => {
+            const retVal: WsMachine.MachineInfoEx[] = [];
+            for (const machineInfo of response.TargetClusterInfoList.TargetClusterInfo) {
+                for (const machineInfoEx of machineInfo.Processes.MachineInfoEx) {
+                    retVal.push(machineInfoEx);
+                }
+            }
+            this.set("MachineInfoEx", retVal);
+            return this.CMachineInfoEx;
+        });
+    }
+
+    machineStats(): { maxDisk: number; meanDisk: number } {
+        let maxDisk = 0;
+        let totalFree = 0;
+        let total = 0;
+        for (const machine of this.CMachineInfoEx) {
+            for (const storageInfo of machine.Storage.StorageInfo) {
+                totalFree += storageInfo.Available;
+                total += storageInfo.Total;
+                const usage = 1 - storageInfo.Available / storageInfo.Total;
+                if (usage > maxDisk) {
+                    maxDisk = usage;
+                }
+            }
+        }
+        return {
+            maxDisk,
+            meanDisk: 1 - (total ? totalFree / total : 1)
+        };
+    }
+
+    fetchUsage(): Promise<WsMachineEx.TargetClusterUsage[]> {
+        return this.machineConnection.GetTargetClusterUsageEx([this.Name]);
+    }
+}
+
+export function targetClusters(optsConnection: IOptions | IConnection | TopologyService): Promise<TargetCluster[]> {
+    let connection: TopologyService;
+    if (optsConnection instanceof TopologyService) {
+        connection = optsConnection;
+    } else {
+        connection = new TopologyService(optsConnection);
+    }
+    return connection.TpListTargetClusters({}).then(response => {
+        return response.TargetClusters.TpClusterNameType.map(item => TargetCluster.attach(optsConnection, item.Name, item));
+    });
+}
+
+const _defaultTargetCluster: { [baseUrl: string]: Promise<TargetCluster> } = {};
+export function defaultTargetCluster(optsConnection: IOptions | IConnection | TopologyService): Promise<TargetCluster> {
+    if (!_defaultTargetCluster[optsConnection.baseUrl]) {
+        let connection: TopologyService;
+        if (optsConnection instanceof TopologyService) {
+            connection = optsConnection;
+        } else {
+            connection = new TopologyService(optsConnection);
+        }
+        _defaultTargetCluster[optsConnection.baseUrl] = connection.TpListTargetClusters({}).then(response => {
+            let firstItem: WsTopology.TpClusterNameType;
+            let defaultItem: WsTopology.TpClusterNameType;
+            let hthorItem: WsTopology.TpClusterNameType;
+            response.TargetClusters.TpClusterNameType.forEach(item => {
+                if (!firstItem) {
+                    firstItem = item;
+                }
+                if (!defaultItem && item.IsDefault === true) {
+                    defaultItem = item;
+                }
+                if (!hthorItem && item.Type === "hthor") {
+                    hthorItem = item;
+                }
+            });
+            const defItem = defaultItem || hthorItem || firstItem;
+            return TargetCluster.attach(optsConnection, defItem.Name, defItem);
+        });
+    }
+    return _defaultTargetCluster[optsConnection.baseUrl];
+}