node-opcua-client-dynamic-extension-object 2.127.1 → 2.128.0

package/source/get_extra_data_type_manager.ts

@@ -7,7 +7,7 @@ import {
 } from "node-opcua-pseudo-session";
 //
 import { ExtraDataTypeManager } from "./extra_data_type_manager";
-import { populateDataTypeManager } from "./populate_data_type_manager";
+import { DataTypeExtractStrategy, populateDataTypeManager } from "./populate_data_type_manager";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -29,7 +29,7 @@ export async function invalidateExtraDataTypeManager(session: IBasicSessionAsync
     }
 }
 
-async function extractDataTypeManager(session: IBasicSessionAsync2): Promise<ExtraDataTypeManager> {
+export async function extractDataTypeManagerPrivate(session: IBasicSessionAsync2, strategy: DataTypeExtractStrategy): Promise<ExtraDataTypeManager> {
     const namespaceArray = await readNamespaceArray(session);
     // istanbul ignore next
     if (namespaceArray.length === 0) {
@@ -45,7 +45,7 @@ async function extractDataTypeManager(session: IBasicSessionAsync2): Promise<Ext
         const dataTypeFactory1 = new DataTypeFactory([getStandardDataTypeFactory()]);
         dataTypeManager.registerDataTypeFactory(namespaceIndex, dataTypeFactory1);
     }
-    await populateDataTypeManager(session, dataTypeManager);
+    await populateDataTypeManager(session, dataTypeManager, strategy);
     // istanbul ignore next
     if (dataTypeManager.namespaceArray.length === 0) {
         throw new Error("namespaceArray is not populated ! Your server must expose a list of namespace ");
@@ -53,7 +53,18 @@ async function extractDataTypeManager(session: IBasicSessionAsync2): Promise<Ext
     return dataTypeManager;
 }
 
-export async function getExtraDataTypeManager(session: IBasicSessionAsync2): Promise<ExtraDataTypeManager> {
+
+function getStrategy(session: IBasicSessionAsync2, strategy?: DataTypeExtractStrategy): DataTypeExtractStrategy {
+    if (strategy !== undefined) {
+        return strategy;
+    }
+    const client =  (session as any).client;
+    if (client && client.dataTypeExtractStrategy!== undefined) {
+        return client.dataTypeExtractStrategy;
+    }
+    return DataTypeExtractStrategy.Auto;
+}
+export async function getExtraDataTypeManager(session: IBasicSessionAsync2, strategy?: DataTypeExtractStrategy ): Promise<ExtraDataTypeManager> {
     const sessionPriv: IBasicSession_ = session as IBasicSession_;
     if (sessionPriv.$$extraDataTypeManager) {
         return sessionPriv.$$extraDataTypeManager;
@@ -71,7 +82,8 @@ export async function getExtraDataTypeManager(session: IBasicSessionAsync2): Pro
         sessionPriv.$$extraDataTypeManagerToResolve!.push([_resolve, _reject]);
         (async () => {
             try {
-                const dataTypeManager = await extractDataTypeManager(session);
+                strategy = getStrategy(session, strategy);
+                const dataTypeManager = await extractDataTypeManagerPrivate(session, strategy);
                 const tmp = sessionPriv.$$extraDataTypeManagerToResolve!;
                 sessionPriv.$$extraDataTypeManagerToResolve = undefined;
                 for (const [resolve] of tmp) {

package/source/populate_data_type_manager.ts

@@ -111,13 +111,33 @@ export async function serverImplementsDataTypeDefinition(
     return false;
 }
 
-export async function populateDataTypeManager(session: IBasicSessionAsync2, dataTypeManager: ExtraDataTypeManager): Promise<void> {
-    const force104 = await serverImplementsDataTypeDefinition(session);
-    if (force104) {
+export enum DataTypeExtractStrategy {
+    Auto = 0,
+    Force103 = 1,
+    Force104 = 2,
+    Both = 3
+};
+
+export async function populateDataTypeManager(
+    session: IBasicSessionAsync2,
+    dataTypeManager: ExtraDataTypeManager, 
+    strategy: DataTypeExtractStrategy
+): Promise<void> {
+    if (strategy === DataTypeExtractStrategy.Auto) {
+        const force104 = await serverImplementsDataTypeDefinition(session);
+        if (force104) {
+            await populateDataTypeManager104(session, dataTypeManager);
+            return;
+        }
+        // old way for 1.03 and early 1.04 prototype
+        await populateDataTypeManager103(session, dataTypeManager);
         await populateDataTypeManager104(session, dataTypeManager);
         return;
     }
-    // old way for 1.03 and early 1.04 prototype
-    await populateDataTypeManager103(session, dataTypeManager);
-    await populateDataTypeManager104(session, dataTypeManager);
+    if (strategy == DataTypeExtractStrategy.Force103|| strategy == DataTypeExtractStrategy.Both) {
+        await populateDataTypeManager103(session, dataTypeManager);
+    }
+    if (strategy == DataTypeExtractStrategy.Force104 || strategy == DataTypeExtractStrategy.Both) {
+        await populateDataTypeManager104(session, dataTypeManager);
+    }
 }

package/source/private/populate_data_type_manager_103.ts

@@ -273,7 +273,7 @@ function sortStructure(dataTypeDefinitions: DataTypeDefinitions) {
 const readIsAbstract = async (session: IBasicSessionAsync, nodeId: NodeId): Promise<boolean> => {
     const dataValue = await session.read({ nodeId, attributeId: AttributeIds.IsAbstract });
     return dataValue.value.value;
-}
+};
 
 async function _extractDataTypeDictionaryFromDefinition(
     session: IBasicSessionAsync2,
@@ -300,6 +300,8 @@ async function _extractDataTypeDictionaryFromDefinition(
     const dataTypeDefinitions: DataTypeDefinitions = [];
 
     let index = 0;
+
+    const promise: Promise<void>[] = [];
     for (const dataValue of dataValuesWithDataTypeDefinition) {
         const dataTypeNodeId = dataTypeNodeIds[index];
         const dataTypeDescription = dataTypeDescriptions[index];
@@ -310,10 +312,10 @@ async function _extractDataTypeDictionaryFromDefinition(
 
             if (dataTypeDefinition && dataTypeDefinition instanceof StructureDefinition) {
                 const className = dataTypeDescription.browseName.name!;
-
-                const isAbstract = await readIsAbstract(session, dataTypeNodeId);
-
-                dataTypeDefinitions.push({ className, dataTypeNodeId, dataTypeDefinition, isAbstract });
+                promise.push((async () => {
+                    const isAbstract = await readIsAbstract(session, dataTypeNodeId);
+                    dataTypeDefinitions.push({ className, dataTypeNodeId, dataTypeDefinition, isAbstract });
+                })());
             }
         } else {
             debugLog(
@@ -325,56 +327,65 @@ async function _extractDataTypeDictionaryFromDefinition(
         }
         index++;
     }
+    await Promise.all(promise);
+
     // to do put in logical order
     const dataTypeDefinitionsSorted = sortStructure(dataTypeDefinitions);
     // istanbul ignore next
     if (doDebug) {
         debugLog("order ", dataTypeDefinitionsSorted.map((a) => a.className + " " + a.dataTypeNodeId).join(" ->  "));
     }
+
+    const promises2: Promise<void>[] = [];
+
     for (const { className, dataTypeNodeId, dataTypeDefinition, isAbstract } of dataTypeDefinitionsSorted) {
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog(chalk.yellow("--------------------------------------- "), className, dataTypeNodeId.toString());
-        }
-        if (dataTypeFactory.hasStructureByTypeName(className)) {
-            continue; // this structure has already been seen
-        }
-        // now fill typeDictionary
-        try {
-            const dataTypeDescription = dataTypeDescriptions.find((a)=>a.nodeId.toString() === dataTypeNodeId.toString());
-            if (!dataTypeDefinition) {
-                throw new Error("cannot find dataTypeDefinition for "+ dataTypeNodeId.toString());
-            }
-            const schema = await convertDataTypeDefinitionToStructureTypeSchema(
-                session,
-                dataTypeNodeId,
-                className,
-                dataTypeDefinition,
-                dataTypeDescription!, // for encodings
-                dataTypeFactory,
-                isAbstract,
-                cache
-            );
 
+        promises2.push((async () => {
             // istanbul ignore next
             if (doDebug) {
-                debugLog(chalk.red("Registering "), chalk.cyan(className.padEnd(30, " ")), schema.dataTypeNodeId.toString());
+                debugLog(chalk.yellow("--------------------------------------- "), className, dataTypeNodeId.toString());
             }
-            if (!isAbstract) {
-                const Constructor = createDynamicObjectConstructor(schema, dataTypeFactory) as unknown as ConstructorFuncWithSchema;
-                assert(Constructor.schema === schema);
-            } else {
+            if (dataTypeFactory.hasStructureByTypeName(className)) {
+                return; // this structure has already been seen
+            }
+            // now fill typeDictionary
+            try {
+                const dataTypeDescription = dataTypeDescriptions.find((a) => a.nodeId.toString() === dataTypeNodeId.toString());
+                if (!dataTypeDefinition) {
+                    throw new Error("cannot find dataTypeDefinition for " + dataTypeNodeId.toString());
+                }
+                const schema = await convertDataTypeDefinitionToStructureTypeSchema(
+                    session,
+                    dataTypeNodeId,
+                    className,
+                    dataTypeDefinition,
+                    dataTypeDescription!, // for encodings
+                    dataTypeFactory,
+                    isAbstract,
+                    cache
+                );
+
                 // istanbul ignore next
                 if (doDebug) {
-                    debugLog("Ignoring Abstract ", className);
+                    debugLog(chalk.red("Registering "), chalk.cyan(className.padEnd(30, " ")), schema.dataTypeNodeId.toString());
+                }
+                if (!isAbstract) {
+                    const Constructor = createDynamicObjectConstructor(schema, dataTypeFactory) as unknown as ConstructorFuncWithSchema;
+                    assert(Constructor.schema === schema);
+                } else {
+                    // istanbul ignore next
+                    if (doDebug) {
+                        debugLog("Ignoring Abstract ", className);
+                    }
                 }
+            } catch (err) {
+                errorLog("Constructor verification err: ", (<Error>err).message);
+                errorLog("For this reason class " + className + " has not been registered");
+                errorLog(err);
             }
-        } catch (err) {
-            errorLog("Constructor verification err: ", (<Error>err).message);
-            errorLog("For this reason class " + className + " has not been registered");
-            errorLog(err);
-        }
+        })());
     }
+    await Promise.all(promises2);
 }
 
 async function _extractNodeIds(
@@ -420,18 +431,20 @@ async function _extractDataTypeDictionary(
 ): Promise<void> {
     const dataTypeDictionaryNodeId = d.reference.nodeId;
 
-    const name = await session.read({ nodeId: dataTypeDictionaryNodeId, attributeId: AttributeIds.BrowseName });
-    const namespace = await _readNamespaceUriProperty(session, dataTypeDictionaryNodeId);
-
     if (!_isOldDataTypeDictionary(d)) {
-        debugLog(
-            "DataTypeDictionary is deprecated or BSD schema stored in dataValue is null !",
-            chalk.cyan(name.value.value.toString()),
-            "namespace =",
-            namespace
-        );
-        debugLog("let's use the new way (1.04) and let's explore all dataTypes exposed by this name space");
-
+        if (doDebug) {
+            const [name, namespace] = await Promise.all([
+                session.read({ nodeId: dataTypeDictionaryNodeId, attributeId: AttributeIds.BrowseName }),
+                _readNamespaceUriProperty(session, dataTypeDictionaryNodeId)
+            ]);
+            debugLog(
+                "DataTypeDictionary is deprecated or BSD schema stored in dataValue is null !",
+                chalk.cyan(name.value.value.toString()),
+                "namespace =",
+                namespace
+            );
+            debugLog("let's use the new way (1.04) and let's explore all dataTypes exposed by this name space");
+        }
         // dataType definition in store directly in UADataType under the definition attribute
         const dataTypeFactory2 = dataTypeManager.getDataTypeFactory(dataTypeDictionaryNodeId.namespace);
         if (!dataTypeFactory2) {
@@ -780,18 +793,13 @@ export async function populateDataTypeManager103(
         await _exploreDataTypeDefinition(session, dataTypeDictionaryNodeId, dataTypeFactory, dataTypeManager.namespaceArray);
     }
 
+    const promises: Promise<void>[] = [];
+
     // https://medium.com/swlh/dealing-with-multiple-promises-in-javascript-41d6c21f20ff
     for (const d of dataTypeDictionaryInfo) {
-        try {
-            await processReferenceOnDataTypeDictionaryType(d).catch((e) => {
-                debugLog("processReferenceOnDataTypeDictionaryType has failed ");
-                debugLog("Error", e.message);
-                debugLog(e);
-                return e;
-            });
-        } catch (err) {
-            debugLog(chalk.red("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "), err);
-        }
+        promises.push(processReferenceOnDataTypeDictionaryType(d));
     }
+    await Promise.all(promises);
+
     debugLog("out ... populateDataTypeManager");
 }

package/source/private/populate_data_type_manager_104.ts

@@ -1,35 +1,32 @@
 import { AttributeIds, BrowseDirection } from "node-opcua-data-model";
-import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { DataTypeFactory } from "node-opcua-factory";
-import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { NodeId, resolveNodeId, NodeIdLike } from "node-opcua-nodeid";
 import { IBasicSessionAsync2, IBasicSessionBrowseAsync, IBasicSessionBrowseNext, IBasicSessionReadAsync, IBasicSessionTranslateBrowsePathAsync, browseAll } from "node-opcua-pseudo-session";
 import { createDynamicObjectConstructor as createDynamicObjectConstructorAndRegister } from "node-opcua-schemas";
-import { StatusCodes } from "node-opcua-status-code";
 import {
     ReferenceDescription,
-    BrowseResult,
     BrowseDescriptionOptions,
     StructureDefinition,
-    DataTypeDefinition,
-    BrowseDescription
-} from "node-opcua-types";
+    DataTypeDefinition} from "node-opcua-types";
 //
 import { ExtraDataTypeManager } from "../extra_data_type_manager";
 import {
-    CacheForFieldResolution,
+    ICache,
     convertDataTypeDefinitionToStructureTypeSchema
 } from "../convert_data_type_definition_to_structuretype_schema";
 
 const errorLog = make_errorLog(__filename);
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
+const doDebug = checkDebugFlag(__filename);
 
 export async function readDataTypeDefinitionAndBuildType(
     session: IBasicSessionAsync2,
     dataTypeNodeId: NodeId,
     name: string,
     dataTypeFactory: DataTypeFactory,
-    cache: { [key: string]: CacheForFieldResolution }
+    cache: ICache
 ): Promise<void> {
     try {
         if (dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId)) {
@@ -55,8 +52,14 @@ export async function readDataTypeDefinitionAndBuildType(
         /* istanbul ignore next */
         if (dataTypeDefinitionDataValue.statusCode.isNotGood()) {
             // may be we are reading a 1.03 server
+            // or it could be some of the di:ParameterResultDataType that are not marked as abstract
+            // in some cases
             if (!isAbstract) {
-                warningLog(" Cannot find dataType Definition ! with nodeId =" + dataTypeNodeId.toString());
+                const [isAbstract2, browseNameDV] = await session.read([
+                    { nodeId: dataTypeNodeId, attributeId: AttributeIds.IsAbstract },
+                    { nodeId: dataTypeNodeId, attributeId: AttributeIds.BrowseName }
+                ]);
+                warningLog(" Cannot find dataType Definition ! with nodeId =" + dataTypeNodeId.toString(), browseNameDV.value?.value?.toString(), isAbstract2.value?.value);
                 return;
             }
             // it is OK to not have dataTypeDefinition for Abstract type!
@@ -84,118 +87,14 @@ export async function readDataTypeDefinitionAndBuildType(
     }
 }
 
-class TaskMan {
-    private readonly taskList: (() => Promise<void>)[] = [];
-    private _runningTask = false;
-    private _resolve: (() => void) | undefined = undefined;
-
-    async flushTaskList() {
-        const firstTask = this.taskList.shift()!;
-        this._runningTask = true;
-        await firstTask();
-        this._runningTask = false;
-        if (this.taskList.length > 0) {
-            setImmediate(async () => {
-                await this.flushTaskList();
-            });
-        } else {
-            if (this._resolve) {
-                const tmpResolve = this._resolve;
-                this._resolve = undefined;
-                tmpResolve();
-            }
-        }
-    }
-    /**
-     *
-     * a little async task queue that gets executed sequentially
-     * outside the main loop
-     */
-    public registerTask(taskFunc: () => Promise<void>) {
-        this.taskList.push(taskFunc);
-        if (this.taskList.length === 1 && !this._runningTask) {
-            this.flushTaskList();
-        }
-    }
-    public async waitForCompletion() {
-        if (this._resolve !== undefined) {
-            throw new Error("already waiting");
-        }
-        await new Promise<void>((resolve) => {
-            this._resolve = resolve;
-        });
-    }
-}
-
-async function applyOnReferenceRecursively(
-    session: IBasicSessionTranslateBrowsePathAsync & IBasicSessionReadAsync & IBasicSessionBrowseAsync & IBasicSessionBrowseNext,
-    nodeId: NodeId,
-    browseDescriptionTemplate: BrowseDescriptionOptions,
-    action: (ref: ReferenceDescription) => Promise<void>
-): Promise<void> {
-    const taskManager = new TaskMan();
-
-    let pendingNodesToBrowse: BrowseDescriptionOptions[] = [];
-
-    function processBrowseResults(nodesToBrowse: BrowseDescriptionOptions[], browseResults: BrowseResult[]) {
-        for (let i = 0; i < browseResults.length; i++) {
-            const result = browseResults[i];
-            const nodeToBrowse = nodesToBrowse[i];
-            if (
-                result.statusCode.equals(StatusCodes.BadNoContinuationPoints) ||
-                result.statusCode.equals(StatusCodes.BadContinuationPointInvalid)
-            ) {
-                // not enough continuation points .. we need to rebrowse
-                pendingNodesToBrowse.push(nodeToBrowse);
-                //                taskManager.registerTask(flushBrowse);
-            } else if (result.statusCode.isGood()) {
-                for (const r of result.references || []) {
-                    // also explore sub types
-                    browseSubDataTypeRecursively(r.nodeId);
-                    taskManager.registerTask(async () => await action(r));
-                }
-            } else {
-                errorLog(
-                    "Unexpected status code",
-                    i,
-                    new BrowseDescription(nodesToBrowse[i] || {})?.toString(),
-                    result.statusCode.toString()
-                );
-            }
-        }
-    }
-    async function flushBrowse() {
-        if (pendingNodesToBrowse.length) {
-            const nodesToBrowse = pendingNodesToBrowse;
-            pendingNodesToBrowse = [];
-            taskManager.registerTask(async () => {
-                try {
-                    const browseResults = await browseAll(session, nodesToBrowse);
-                    processBrowseResults(nodesToBrowse, browseResults);
-                } catch (err) {
-                    errorLog("err", (err as Error).message);
-                    errorLog(nodesToBrowse.toString());
-                }
-            });
-        }
-    }
-
-    function browseSubDataTypeRecursively(nodeId: NodeId): void {
-        const nodeToBrowse: BrowseDescriptionOptions = {
-            ...browseDescriptionTemplate,
-            nodeId
-        };
-        pendingNodesToBrowse.push(nodeToBrowse);
-        taskManager.registerTask(async () => flushBrowse());
-    }
-    browseSubDataTypeRecursively(nodeId);
-    await taskManager.waitForCompletion();
-}
 export async function populateDataTypeManager104(
     session: IBasicSessionAsync2,
     dataTypeManager: ExtraDataTypeManager
 ): Promise<void> {
-    const cache: { [key: string]: CacheForFieldResolution } = {};
+
+
+
+    const cache: ICache = {};
 
     async function withDataType(r: ReferenceDescription): Promise<void> {
         const dataTypeNodeId = r.nodeId;
@@ -216,7 +115,7 @@ export async function populateDataTypeManager104(
                 return;
             }
             // extract it formally
-            debugLog(" DataType => ", r.browseName.toString(), dataTypeNodeId.toString());
+            doDebug && debugLog(" DataType => ", r.browseName.toString(), dataTypeNodeId.toString());
             await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, r.browseName.name!, dataTypeFactory, cache);
         } catch (err) {
             errorLog("err=", err);
@@ -233,3 +132,31 @@ export async function populateDataTypeManager104(
     };
     await applyOnReferenceRecursively(session, resolveNodeId("Structure"), nodeToBrowse, withDataType);
 }
+async function applyOnReferenceRecursively(
+    session: IBasicSessionTranslateBrowsePathAsync & IBasicSessionReadAsync & IBasicSessionBrowseAsync & IBasicSessionBrowseNext,
+    nodeId: NodeId,
+    browseDescriptionTemplate: BrowseDescriptionOptions,
+    action: (ref: ReferenceDescription) => Promise<void>
+): Promise<void> {
+
+
+    const oneLevel = async (nodeId: NodeIdLike) => {
+
+        const nodeToBrowse: BrowseDescriptionOptions = {
+            ...browseDescriptionTemplate,
+            nodeId
+        };
+
+        const browseResult = await browseAll(session, nodeToBrowse);
+
+        const promises: Promise<void>[] = [];
+        for (const ref of browseResult.references || []) {
+            promises.push((async () => {
+                await action(ref);
+                await oneLevel(ref.nodeId);
+            })());
+        }
+        await Promise.all(promises);
+    };
+    await oneLevel(nodeId);
+}