node-opcua-client-dynamic-extension-object 2.51.0

package/source/private/populate_data_type_manager_104.ts

@@ -0,0 +1,153 @@
+import { assert } from "node-opcua-assert";
+import { AttributeIds, BrowseDirection } from "node-opcua-data-model";
+import { DataTypeFactory } from "node-opcua-factory";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { IBasicSession, BrowseDescriptionLike } from "node-opcua-pseudo-session";
+import { createDynamicObjectConstructor } from "node-opcua-schemas";
+import { StatusCodes } from "node-opcua-status-code";
+import { ReferenceDescription, BrowseResult } from "node-opcua-types";
+
+//
+import { ExtraDataTypeManager } from "../extra_data_type_manager";
+import {
+    CacheForFieldResolution,
+    convertDataTypeDefinitionToStructureTypeSchema
+} from "../convert_data_type_definition_to_structuretype_schema";
+import { make_debugLog, make_errorLog } from "node-opcua-debug";
+const errorLog = make_errorLog(__filename);
+const debugLog =make_debugLog(__filename);
+
+export async function readDataTypeDefinitionAndBuildType(
+    session: IBasicSession,
+    dataTypeNodeId: NodeId,
+    name: string,
+    dataTypeFactory: DataTypeFactory,
+    cache: { [key: string]: CacheForFieldResolution } 
+) {
+    try {
+        const dataTypeDefinitionDataValue = await session.read({
+            attributeId: AttributeIds.DataTypeDefinition,
+            nodeId: dataTypeNodeId
+        });
+        /* istanbul ignore next */
+        if (dataTypeDefinitionDataValue.statusCode !== StatusCodes.Good) {
+            throw new Error(" Cannot find dataType Definition ! with nodeId =" + dataTypeNodeId.toString());
+        }
+        const dataTypeDefinition = dataTypeDefinitionDataValue.value.value;
+
+        const schema = await convertDataTypeDefinitionToStructureTypeSchema(
+            session,
+            dataTypeNodeId,
+            name,
+            dataTypeDefinition,
+            dataTypeFactory,
+            cache
+        );
+
+        createDynamicObjectConstructor(schema, dataTypeFactory);
+    } catch (err) {
+        errorLog("Error", err);
+    }
+}
+
+export async function populateDataTypeManager104(session: IBasicSession, dataTypeManager: ExtraDataTypeManager): Promise<void> {
+
+    const cache: { [key: string]: CacheForFieldResolution } = {};
+    
+    async function withDataType(dataTypeNodeId: NodeId, r: ReferenceDescription): Promise<void> {
+        try {
+            const dataTypeFactory = dataTypeManager.getDataTypeFactory(dataTypeNodeId.namespace);
+            if (dataTypeNodeId.namespace === 0) {
+                // already known I guess
+                return;
+            }
+            // if not found already
+            if (dataTypeFactory.getConstructorForDataType(dataTypeNodeId)) {
+                // already known !
+                return;
+            }
+            // extract it formally
+            debugLog(" DataType => ", r.browseName.toString(), dataTypeNodeId.toString());
+            await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, r.browseName.name!, dataTypeFactory, cache);
+            assert(dataTypeFactory.getConstructorForDataType(dataTypeNodeId));
+        } catch (err) {
+            errorLog("err=", err);
+        }
+    }
+
+    function performAction(done: () => void) {
+        let pendingNodesToBrowse: BrowseDescriptionLike[] = [];
+        let pendingContinuationPoints: Buffer[] = [];
+        function triggerFutureBrowse() {
+            if (pendingNodesToBrowse.length + pendingContinuationPoints.length === 1) {
+                fencedAction(async ()=>{
+                    flushBrowse();
+                });
+            }
+        }
+        let busyCount = 0;
+        function processBrowseResult(browseResults: BrowseResult[]) {
+        
+            for (const result of browseResults) {
+                if (result.statusCode === StatusCodes.Good) {
+                    if (result.continuationPoint) {
+                        pendingContinuationPoints.push(result.continuationPoint);
+                        triggerFutureBrowse();
+                    }
+                    for (const r of result.references || []) {
+                        const dataTypeNodeId = r.nodeId;
+                        fencedAction(async ()=>{
+                            await withDataType(dataTypeNodeId, r);
+                        });
+                        // also explore sub types
+                        browseSubDataTypeRecursively(dataTypeNodeId);
+                    }
+                }
+            }
+        }
+
+        async function fencedAction(lambda: () => Promise<void>) {
+            busyCount += 1;
+            await lambda();
+            busyCount -= 1;
+            flushBrowse();
+        }
+        function flushBrowse() {
+            assert(busyCount >= 0);
+            if (pendingContinuationPoints.length) {
+                const continuationPoints = pendingContinuationPoints;
+                pendingContinuationPoints = [];
+                fencedAction(async () => {
+                    const browseResults = await session.browseNext(continuationPoints, false);
+                    processBrowseResult(browseResults);
+                });
+            } else if (pendingNodesToBrowse.length) {
+                const nodesToBrowse = pendingNodesToBrowse;
+                pendingNodesToBrowse = [];
+
+                fencedAction(async () => {
+                    const browseResults = await session.browse(nodesToBrowse);
+                    processBrowseResult(browseResults);
+                });
+            } else if (pendingContinuationPoints.length + pendingNodesToBrowse.length === 0 && busyCount === 0) {
+                done();
+            }
+        }
+
+        function browseSubDataTypeRecursively(nodeId: NodeId): void {
+            const nodeToBrowse: BrowseDescriptionLike = {
+                nodeId,
+                includeSubtypes: true,
+                browseDirection: BrowseDirection.Forward,
+                nodeClassMask: 0xff,
+                referenceTypeId: resolveNodeId("HasSubtype"),
+                resultMask: 0xff
+            };
+            pendingNodesToBrowse.push(nodeToBrowse);
+            triggerFutureBrowse();
+        }
+
+        browseSubDataTypeRecursively(resolveNodeId("Structure"));
+    }
+    await new Promise<void>((resolve) => performAction(resolve));
+}

package/source/promote_opaque_structure.ts

@@ -0,0 +1,42 @@
+import { OpaqueStructure } from "node-opcua-extension-object";
+import { IBasicSession } from "node-opcua-pseudo-session";
+import { DataType, VariantArrayType, Variant } from "node-opcua-variant";
+//
+import { getExtraDataTypeManager } from "./get_extra_data_type_manager";
+import { resolveDynamicExtensionObject } from "./resolve_dynamic_extension_object";
+
+
+export interface PseudoDataValue { value: Variant };
+
+export async function promoteOpaqueStructure(
+    session: IBasicSession,
+    dataValues: PseudoDataValue[]
+) {
+
+    // count number of Opaque Structures
+    const dataValuesToFix = dataValues.filter((dataValue: PseudoDataValue) =>
+        dataValue.value && dataValue.value.dataType === DataType.ExtensionObject &&
+        (
+            (dataValue.value.arrayType === VariantArrayType.Scalar
+                && dataValue.value.value instanceof OpaqueStructure)
+            ||
+            (dataValue.value.arrayType !== VariantArrayType.Scalar
+                && dataValue.value.value && dataValue.value.value.length >= 0
+                && dataValue.value.value[0] instanceof OpaqueStructure)
+        )
+    );
+
+    if (dataValuesToFix.length === 0) {
+        return;
+    }
+
+    // construct dataTypeManager if not already present
+    const extraDataTypeManager = await getExtraDataTypeManager(session);
+
+    const promises = dataValuesToFix.map(
+        async (dataValue: PseudoDataValue) => {
+            return await resolveDynamicExtensionObject(session, dataValue.value, extraDataTypeManager)
+        });
+    // https://medium.com/swlh/dealing-with-multiple-promises-in-javascript-41d6c21f20ff
+    await Promise.all(promises.map(p => p.catch(e => e)));
+}

package/source/resolve_dynamic_extension_object.ts

@@ -0,0 +1,104 @@
+import { BinaryStream } from "node-opcua-binary-stream";
+import { ExtensionObject, OpaqueStructure } from "node-opcua-extension-object";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import { hexDump, make_warningLog } from "node-opcua-debug";
+//
+import { ExtraDataTypeManager } from "./extra_data_type_manager";
+import { IBasicSession } from "node-opcua-pseudo-session";
+import { NodeId } from "node-opcua-nodeid";
+import { ConstructorFunc } from "node-opcua-factory";
+import { BrowseDirection, NodeClassMask, ResultMask } from "node-opcua-data-model";
+import { StatusCodes } from "node-opcua-status-code";
+import { readDataTypeDefinitionAndBuildType } from "./private/populate_data_type_manager_104";
+
+const warningLog = make_warningLog(__filename);
+
+async function getOrExtractConstructor(session: IBasicSession, binaryEncodingNodeId: NodeId, dataTypeManager: ExtraDataTypeManager): Promise<ConstructorFunc>
+{
+    const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(binaryEncodingNodeId.namespace);
+    const Constructor = dataTypeFactory.getConstructor(binaryEncodingNodeId);
+    if (Constructor) {
+        return Constructor;
+    }
+    if (binaryEncodingNodeId.namespace ===0) {
+        throw new Error("Internal Error"); 
+    }
+    // need to extract it
+    const browseResult = await session.browse({
+        nodeId: binaryEncodingNodeId,
+        referenceTypeId: "HasEncoding",
+        browseDirection: BrowseDirection.Inverse,
+        includeSubtypes: false,
+        nodeClassMask: NodeClassMask.DataType,
+        resultMask: ResultMask.BrowseName
+    });
+    if (browseResult.statusCode !== StatusCodes.Good || browseResult.references!.length !== 1) {
+        throw new Error("browse failed");
+    }
+    const r =  browseResult.references![0];
+    const dataTypeNodeId =r.nodeId;
+
+    if (dataTypeFactory.getConstructorForDataType(dataTypeNodeId)) {
+        throw new Error("Internal Error: we are not expecting this dataType to be processed already"); 
+    }
+    await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, r.browseName.name!, dataTypeFactory, {});
+    
+    return dataTypeFactory.getConstructorForDataType(dataTypeNodeId)!;
+}
+
+async function resolveDynamicExtensionObjectV(
+    session: IBasicSession,
+    opaque: OpaqueStructure,
+    dataTypeManager: ExtraDataTypeManager
+): Promise<ExtensionObject> {
+    try {
+        const Constructor = await getOrExtractConstructor(session, opaque.nodeId, dataTypeManager);
+        const object = new Constructor();
+        const stream = new BinaryStream(opaque.buffer);
+        try {
+            object.decode(stream);
+            return object;
+        } catch (err) {
+            warningLog("Constructor = ", Constructor.name);
+            warningLog("opaqueStructure = ", opaque?.nodeId?.toString());
+            warningLog("opaqueStructure = ", "0x" + opaque?.buffer?.toString("hex"));
+            warningLog(hexDump(opaque.buffer));
+            warningLog("resolveDynamicExtensionObjectV err = ", err);
+            // try again for debugging
+            object.decode(stream);
+            return opaque;
+        }
+    } catch (err) {
+        warningLog("err", err);
+        warningLog("opaqueStructure = ", opaque.nodeId.toString());
+        warningLog("opaqueStructure = ", "0x" + opaque.buffer.toString("hex"));
+        warningLog(hexDump(opaque.buffer));
+        warningLog(dataTypeManager.toString());
+        throw err;
+    }
+}
+
+export async function resolveDynamicExtensionObject(
+    session: IBasicSession,
+    variant: Variant,
+    dataTypeManager: ExtraDataTypeManager
+): Promise<void> {
+    if (variant.dataType !== DataType.ExtensionObject) {
+        return;
+    }
+    if (variant.arrayType !== VariantArrayType.Scalar) {
+        if (variant.value instanceof Array) {
+            for (let i = 0; i < variant.value.length; i++) {
+                if (variant.value[i] instanceof OpaqueStructure) {
+                    variant.value[i] = await resolveDynamicExtensionObjectV(session, variant.value[i], dataTypeManager);
+                }
+            }
+        }
+        return;
+    }
+
+    if (!(variant.value instanceof OpaqueStructure)) {
+        return;
+    }
+    variant.value = await resolveDynamicExtensionObjectV(session, variant.value as OpaqueStructure, dataTypeManager);
+}