@hpcc-js/comms 3.15.4 → 3.15.6

package/src/services/wsMachine.ts

@@ -1,89 +1,89 @@
-import { exists } from "@hpcc-js/util";
-import { max as d3Max, mean as d3Mean } from "d3-array";
-
-import { MachineServiceBase, WsMachine } from "./wsdl/ws_machine/v1.19/ws_machine.ts";
-
-export {
-    type WsMachine
-};
-
-export namespace WsMachineEx {
-
-    export interface DiskUsage extends WsMachine.DiskUsage {
-        Total: number;
-        PercentUsed: number;
-    }
-
-    export interface MachineUsage extends Omit<WsMachine.MachineUsage, "DiskUsages"> {
-        DiskUsages: DiskUsage[];
-        mean: number;
-        max: number;
-    }
-
-    export interface ComponentUsage extends Omit<WsMachine.ComponentUsage, "MachineUsages"> {
-        MachineUsages: MachineUsage[];
-        MachineUsagesDescription: string;
-        mean: number;
-        max: number;
-    }
-
-    export interface TargetClusterUsage extends Omit<WsMachine.TargetClusterUsage, "ComponentUsages"> {
-        ComponentUsages: ComponentUsage[];
-        ComponentUsagesDescription: string;
-        mean: number;
-        max: number;
-    }
-
-}
-
-export class MachineService extends MachineServiceBase {
-
-    GetTargetClusterUsageEx(targetClusters?: string[], bypassCachedResult: boolean = false): Promise<WsMachineEx.TargetClusterUsage[]> {
-        return this._connection.send("GetTargetClusterUsage", {
-            TargetClusters: targetClusters ? { Item: targetClusters } : {},
-            BypassCachedResult: bypassCachedResult
-        }).then(response => {
-            return exists("TargetClusterUsages.TargetClusterUsage", response) ? response.TargetClusterUsages.TargetClusterUsage : [];
-        }).then(response => {
-            return response.filter(tcu => !!tcu.ComponentUsages).map(tcu => {
-                const ComponentUsages: WsMachineEx.ComponentUsage[] = tcu.ComponentUsages.ComponentUsage.map(cu => {
-                    const MachineUsages: WsMachineEx.MachineUsage[] = (cu.MachineUsages && cu.MachineUsages.MachineUsage ? cu.MachineUsages.MachineUsage : []).map(mu => {
-                        const DiskUsages: WsMachineEx.DiskUsage[] = mu.DiskUsages && mu.DiskUsages.DiskUsage ? mu.DiskUsages.DiskUsage.map(du => {
-                            return {
-                                ...du,
-                                InUse: du.InUse * 1024,
-                                Total: (du.InUse + du.Available) * 1024,
-                                PercentUsed: 100 - du.PercentAvailable
-                            };
-                        }) : [];
-                        return {
-                            Name: mu.Name,
-                            NetAddress: mu.NetAddress,
-                            Description: mu.Description,
-                            DiskUsages,
-                            mean: d3Mean(DiskUsages.filter(du => !isNaN(du.PercentUsed)), du => du.PercentUsed),
-                            max: d3Max(DiskUsages.filter(du => !isNaN(du.PercentUsed)), du => du.PercentUsed)
-                        };
-                    });
-                    return {
-                        Type: cu.Type,
-                        Name: cu.Name,
-                        Description: cu.Description,
-                        MachineUsages,
-                        MachineUsagesDescription: MachineUsages.reduce((prev, mu) => prev + (mu.Description || ""), ""),
-                        mean: d3Mean(MachineUsages.filter(mu => !isNaN(mu.mean)), mu => mu.mean),
-                        max: d3Max(MachineUsages.filter(mu => !isNaN(mu.max)), mu => mu.max)
-                    };
-                });
-                return {
-                    Name: tcu.Name,
-                    Description: tcu.Description,
-                    ComponentUsages,
-                    ComponentUsagesDescription: ComponentUsages.reduce((prev, cu) => prev + (cu.MachineUsagesDescription || ""), ""),
-                    mean: d3Mean(ComponentUsages.filter(cu => !isNaN(cu.mean)), cu => cu.mean),
-                    max: d3Max(ComponentUsages.filter(cu => !isNaN(cu.max)), cu => cu.max)
-                };
-            });
-        });
-    }
-}
+import { exists } from "@hpcc-js/util";
+import { max as d3Max, mean as d3Mean } from "d3-array";
+
+import { MachineServiceBase, WsMachine } from "./wsdl/ws_machine/v1.19/ws_machine.ts";
+
+export {
+    type WsMachine
+};
+
+export namespace WsMachineEx {
+
+    export interface DiskUsage extends WsMachine.DiskUsage {
+        Total: number;
+        PercentUsed: number;
+    }
+
+    export interface MachineUsage extends Omit<WsMachine.MachineUsage, "DiskUsages"> {
+        DiskUsages: DiskUsage[];
+        mean: number;
+        max: number;
+    }
+
+    export interface ComponentUsage extends Omit<WsMachine.ComponentUsage, "MachineUsages"> {
+        MachineUsages: MachineUsage[];
+        MachineUsagesDescription: string;
+        mean: number;
+        max: number;
+    }
+
+    export interface TargetClusterUsage extends Omit<WsMachine.TargetClusterUsage, "ComponentUsages"> {
+        ComponentUsages: ComponentUsage[];
+        ComponentUsagesDescription: string;
+        mean: number;
+        max: number;
+    }
+
+}
+
+export class MachineService extends MachineServiceBase {
+
+    GetTargetClusterUsageEx(targetClusters?: string[], bypassCachedResult: boolean = false): Promise<WsMachineEx.TargetClusterUsage[]> {
+        return this._connection.send("GetTargetClusterUsage", {
+            TargetClusters: targetClusters ? { Item: targetClusters } : {},
+            BypassCachedResult: bypassCachedResult
+        }).then(response => {
+            return exists("TargetClusterUsages.TargetClusterUsage", response) ? response.TargetClusterUsages.TargetClusterUsage : [];
+        }).then(response => {
+            return response.filter(tcu => !!tcu.ComponentUsages).map(tcu => {
+                const ComponentUsages: WsMachineEx.ComponentUsage[] = tcu.ComponentUsages.ComponentUsage.map(cu => {
+                    const MachineUsages: WsMachineEx.MachineUsage[] = (cu.MachineUsages && cu.MachineUsages.MachineUsage ? cu.MachineUsages.MachineUsage : []).map(mu => {
+                        const DiskUsages: WsMachineEx.DiskUsage[] = mu.DiskUsages && mu.DiskUsages.DiskUsage ? mu.DiskUsages.DiskUsage.map(du => {
+                            return {
+                                ...du,
+                                InUse: du.InUse * 1024,
+                                Total: (du.InUse + du.Available) * 1024,
+                                PercentUsed: 100 - du.PercentAvailable
+                            };
+                        }) : [];
+                        return {
+                            Name: mu.Name,
+                            NetAddress: mu.NetAddress,
+                            Description: mu.Description,
+                            DiskUsages,
+                            mean: d3Mean(DiskUsages.filter(du => !isNaN(du.PercentUsed)), du => du.PercentUsed),
+                            max: d3Max(DiskUsages.filter(du => !isNaN(du.PercentUsed)), du => du.PercentUsed)
+                        };
+                    });
+                    return {
+                        Type: cu.Type,
+                        Name: cu.Name,
+                        Description: cu.Description,
+                        MachineUsages,
+                        MachineUsagesDescription: MachineUsages.reduce((prev, mu) => prev + (mu.Description || ""), ""),
+                        mean: d3Mean(MachineUsages.filter(mu => !isNaN(mu.mean)), mu => mu.mean),
+                        max: d3Max(MachineUsages.filter(mu => !isNaN(mu.max)), mu => mu.max)
+                    };
+                });
+                return {
+                    Name: tcu.Name,
+                    Description: tcu.Description,
+                    ComponentUsages,
+                    ComponentUsagesDescription: ComponentUsages.reduce((prev, cu) => prev + (cu.MachineUsagesDescription || ""), ""),
+                    mean: d3Mean(ComponentUsages.filter(cu => !isNaN(cu.mean)), cu => cu.mean),
+                    max: d3Max(ComponentUsages.filter(cu => !isNaN(cu.max)), cu => cu.max)
+                };
+            });
+        });
+    }
+}

package/src/services/wsPackageProcess.ts

@@ -1,8 +1,8 @@
-import { PackageProcessServiceBase, WsPackageProcess } from "./wsdl/WsPackageProcess/v1.07/WsPackageProcess.ts";
-
-export {
-    type WsPackageProcess
-};
-
-export class PackageProcessService extends PackageProcessServiceBase {
-}
+import { PackageProcessServiceBase, WsPackageProcess } from "./wsdl/WsPackageProcess/v1.08/WsPackageProcess.ts";
+
+export {
+    type WsPackageProcess
+};
+
+export class PackageProcessService extends PackageProcessServiceBase {
+}

package/src/services/wsResources.ts

@@ -1,8 +1,8 @@
-import { ResourcesServiceBase, WsResources } from "./wsdl/WsResources/v1.01/WsResources.ts";
-
-export {
-    type WsResources
-};
-
-export class ResourcesService extends ResourcesServiceBase {
-}
+import { ResourcesServiceBase, WsResources } from "./wsdl/WsResources/v1.01/WsResources.ts";
+
+export {
+    type WsResources
+};
+
+export class ResourcesService extends ResourcesServiceBase {
+}

package/src/services/wsSMC.ts

@@ -1,80 +1,80 @@
-import { timeParse } from "d3-time-format";
-import { SMCServiceBase, WsSMC } from "./wsdl/WsSMC/v1.29/WsSMC.ts";
-import { IOptions } from "../connection.ts";
-
-export {
-    WsSMC
-};
-
-const dateParser = timeParse("%Y%m%d%H");
-
-function isNumeric(value: any): boolean {
-    return typeof value === "number" || (typeof value === "string" && value.trim() !== "" && !isNaN(+value));
-}
-
-export interface NormalisedGlobalMetric {
-    Category: string;
-    Start: Date;
-    End: Date;
-    dimensions: { [key: string]: any };
-    stats: { [key: string]: any };
-}
-
-export class SMCService extends SMCServiceBase {
-
-    connectionOptions(): IOptions {
-        return this._connection.opts();
-    }
-
-    Activity(request: WsSMC.Activity): Promise<WsSMC.ActivityResponse> {
-        return super.Activity(request).then(response => {
-            return {
-                Running: {
-                    ActiveWorkunit: []
-                },
-                ...response
-            };
-        });
-    }
-
-    protected parseGlobalMetric(name: string, value: any): any {
-        // Known Prefixes:  Cost, Critical, Definition, Disk, Distribute, Ecl, Enum, Id, Interface, Is, Library, Load, Match, Meta, Num, Original, Output, Patch, Per, Persist, Predicted, Record, Section, Service, Signed, Size, Source, Spill, Target, Time, Updated, When
-        if (name.startsWith("Cost")) {
-            return +value / 1000000;
-        } else if (name.startsWith("Date")) {
-            return dateParser(value);
-        } else if (name.startsWith("Num")) {
-            return +value;
-        } else if (name.startsWith("Time")) {
-            return +value / 1000000000;
-        } else if (name.startsWith("When")) {
-            return new Date(+value / 1000).toISOString();
-        } else if (isNumeric(value)) {
-            return +value;
-        }
-        return value;
-    }
-
-    GetNormalisedGlobalMetrics(request: Partial<WsSMC.GetGlobalMetrics>): Promise<NormalisedGlobalMetric[]> {
-        return super.GetGlobalMetrics(request).then(response => {
-            const retVal: NormalisedGlobalMetric[] = [];
-            for (const metric of response?.GlobalMetrics?.GlobalMetric || []) {
-                const row: NormalisedGlobalMetric = {
-                    Category: metric.Category,
-                    Start: this.parseGlobalMetric("Date", metric.DateTimeRange?.Start),
-                    End: this.parseGlobalMetric("Date", metric.DateTimeRange?.End),
-                    dimensions: {},
-                    stats: {}
-                };
-                for (const dimension of metric.Dimensions?.Dimension || []) {
-                    row.dimensions[dimension.Name] = dimension.Value;
-                }
-                for (const stat of metric.Stats?.Stat || []) {
-                    row.stats[stat.Name] = this.parseGlobalMetric(stat.Name, stat.Value);
-                }
-                retVal.push(row);
-            }
-            return retVal;
-        });
-    }
-}
+import { timeParse } from "d3-time-format";
+import { SMCServiceBase, WsSMC } from "./wsdl/WsSMC/v1.29/WsSMC.ts";
+import { IOptions } from "../connection.ts";
+
+export {
+    WsSMC
+};
+
+const dateParser = timeParse("%Y%m%d%H");
+
+function isNumeric(value: any): boolean {
+    return typeof value === "number" || (typeof value === "string" && value.trim() !== "" && !isNaN(+value));
+}
+
+export interface NormalisedGlobalMetric {
+    Category: string;
+    Start: Date;
+    End: Date;
+    dimensions: { [key: string]: any };
+    stats: { [key: string]: any };
+}
+
+export class SMCService extends SMCServiceBase {
+
+    connectionOptions(): IOptions {
+        return this._connection.opts();
+    }
+
+    Activity(request: WsSMC.Activity): Promise<WsSMC.ActivityResponse> {
+        return super.Activity(request).then(response => {
+            return {
+                Running: {
+                    ActiveWorkunit: []
+                },
+                ...response
+            };
+        });
+    }
+
+    protected parseGlobalMetric(name: string, value: any): any {
+        // Known Prefixes:  Cost, Critical, Definition, Disk, Distribute, Ecl, Enum, Id, Interface, Is, Library, Load, Match, Meta, Num, Original, Output, Patch, Per, Persist, Predicted, Record, Section, Service, Signed, Size, Source, Spill, Target, Time, Updated, When
+        if (name.startsWith("Cost")) {
+            return +value / 1000000;
+        } else if (name.startsWith("Date")) {
+            return dateParser(value);
+        } else if (name.startsWith("Num")) {
+            return +value;
+        } else if (name.startsWith("Time")) {
+            return +value / 1000000000;
+        } else if (name.startsWith("When")) {
+            return new Date(+value / 1000).toISOString();
+        } else if (isNumeric(value)) {
+            return +value;
+        }
+        return value;
+    }
+
+    GetNormalisedGlobalMetrics(request: Partial<WsSMC.GetGlobalMetrics>): Promise<NormalisedGlobalMetric[]> {
+        return super.GetGlobalMetrics(request).then(response => {
+            const retVal: NormalisedGlobalMetric[] = [];
+            for (const metric of response?.GlobalMetrics?.GlobalMetric || []) {
+                const row: NormalisedGlobalMetric = {
+                    Category: metric.Category,
+                    Start: this.parseGlobalMetric("Date", metric.DateTimeRange?.Start),
+                    End: this.parseGlobalMetric("Date", metric.DateTimeRange?.End),
+                    dimensions: {},
+                    stats: {}
+                };
+                for (const dimension of metric.Dimensions?.Dimension || []) {
+                    row.dimensions[dimension.Name] = dimension.Value;
+                }
+                for (const stat of metric.Stats?.Stat || []) {
+                    row.stats[stat.Name] = this.parseGlobalMetric(stat.Name, stat.Value);
+                }
+                retVal.push(row);
+            }
+            return retVal;
+        });
+    }
+}

package/src/services/wsSasha.ts

@@ -1,8 +1,8 @@
-import { SashaServiceBase, WsSasha } from "./wsdl/WsSasha/v1.01/WsSasha.ts";
-
-export {
-    WsSasha
-};
-
-export class SashaService extends SashaServiceBase {
+import { SashaServiceBase, WsSasha } from "./wsdl/WsSasha/v1.01/WsSasha.ts";
+
+export {
+    WsSasha
+};
+
+export class SashaService extends SashaServiceBase {
 }

package/src/services/wsStore.ts

@@ -1,32 +1,32 @@
-import { storeServiceBase as StoreServiceBase, Wsstore as WsStore } from "./wsdl/wsstore/v1.02/wsstore.ts";
-
-export { type WsStore };
-
-export class StoreService extends StoreServiceBase {
-
-    Delete(request: Partial<WsStore.DeleteRequest>): Promise<WsStore.DeleteResponse> {
-        return super.Delete(request).catch(e => {
-            if (e.isESPExceptions && e.Exception.some(e => e.Code === -1)) {
-                //  "Delete" item does not exist  ---
-                return {
-                    Exceptions: undefined,
-                    Success: true
-                } as WsStore.DeleteResponse;
-            }
-            throw e;
-        });
-    }
-
-    Fetch(request: Partial<WsStore.FetchRequest>): Promise<WsStore.FetchResponse> {
-        return super.Fetch(request).catch(e => {
-            if (e.isESPExceptions && e.Exception.some(e => e.Code === -1)) {
-                //  "Fetch" item does not exist  ---
-                return {
-                    Exceptions: undefined,
-                    Value: undefined
-                } as WsStore.FetchResponse;
-            }
-            throw e;
-        });
-    }
-}
+import { storeServiceBase as StoreServiceBase, Wsstore as WsStore } from "./wsdl/wsstore/v1.02/wsstore.ts";
+
+export { type WsStore };
+
+export class StoreService extends StoreServiceBase {
+
+    Delete(request: Partial<WsStore.DeleteRequest>): Promise<WsStore.DeleteResponse> {
+        return super.Delete(request).catch(e => {
+            if (e.isESPExceptions && e.Exception.some(e => e.Code === -1)) {
+                //  "Delete" item does not exist  ---
+                return {
+                    Exceptions: undefined,
+                    Success: true
+                } as WsStore.DeleteResponse;
+            }
+            throw e;
+        });
+    }
+
+    Fetch(request: Partial<WsStore.FetchRequest>): Promise<WsStore.FetchResponse> {
+        return super.Fetch(request).catch(e => {
+            if (e.isESPExceptions && e.Exception.some(e => e.Code === -1)) {
+                //  "Fetch" item does not exist  ---
+                return {
+                    Exceptions: undefined,
+                    Value: undefined
+                } as WsStore.FetchResponse;
+            }
+            throw e;
+        });
+    }
+}

package/src/services/wsTopology.ts

@@ -1,45 +1,45 @@
-import { IOptions } from "../connection.ts";
-import { TopologyServiceBase, WsTopology } from "./wsdl/WsTopology/v1.33/WsTopology.ts";
-
-export {
-    WsTopology
-};
-
-export class TopologyService extends TopologyServiceBase {
-
-    connectionOptions(): IOptions {
-        return this._connection.opts();
-    }
-
-    protocol(): string {
-        const parts = this._connection.opts().baseUrl.split("//");
-        return parts[0];
-    }
-
-    ip(): string {
-        const parts = this._connection.opts().baseUrl.split("//");
-        const parts2 = parts[1].split(":");
-        return parts2[0];
-    }
-
-    DefaultTpLogicalClusterQuery(request: WsTopology.TpLogicalClusterQueryRequest = {}): Promise<WsTopology.TpLogicalCluster> {
-        return this.TpLogicalClusterQuery(request).then((response) => {
-            if ((response as any).default) {
-                return (response as any).default;
-            }
-            let firstHThor;
-            let first;
-            response.TpLogicalClusters.TpLogicalCluster.some((item, idx) => {
-                if (idx === 0) {
-                    first = item;
-                }
-                if (item.Type === "hthor") {
-                    firstHThor = item;
-                    return true;
-                }
-                return false;
-            });
-            return firstHThor || first;
-        });
-    }
-}
+import { IOptions } from "../connection.ts";
+import { TopologyServiceBase, WsTopology } from "./wsdl/WsTopology/v1.33/WsTopology.ts";
+
+export {
+    WsTopology
+};
+
+export class TopologyService extends TopologyServiceBase {
+
+    connectionOptions(): IOptions {
+        return this._connection.opts();
+    }
+
+    protocol(): string {
+        const parts = this._connection.opts().baseUrl.split("//");
+        return parts[0];
+    }
+
+    ip(): string {
+        const parts = this._connection.opts().baseUrl.split("//");
+        const parts2 = parts[1].split(":");
+        return parts2[0];
+    }
+
+    DefaultTpLogicalClusterQuery(request: WsTopology.TpLogicalClusterQueryRequest = {}): Promise<WsTopology.TpLogicalCluster> {
+        return this.TpLogicalClusterQuery(request).then((response) => {
+            if ((response as any).default) {
+                return (response as any).default;
+            }
+            let firstHThor;
+            let first;
+            response.TpLogicalClusters.TpLogicalCluster.some((item, idx) => {
+                if (idx === 0) {
+                    first = item;
+                }
+                if (item.Type === "hthor") {
+                    firstHThor = item;
+                    return true;
+                }
+                return false;
+            });
+            return firstHThor || first;
+        });
+    }
+}