node-opcua-address-space 2.51.0

package/source/continuation_points/continuation_point_manager.ts

@@ -0,0 +1,121 @@
+/**
+ * @module node-opcua-server
+ */
+import { assert } from "node-opcua-assert";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { BrowseResultOptions, ReferenceDescription } from "node-opcua-types";
+import { ContinuationPoint } from "node-opcua-address-space-base";
+
+let counter = 0;
+
+function make_key() {
+    // return crypto.randomBytes(32);
+    counter += 1;
+    return Buffer.from(counter.toString(), "ascii");
+}
+
+export interface ContinuationPointInfo extends BrowseResultOptions {
+    continuationPoint?: ContinuationPoint;
+    references?: ReferenceDescription[];
+    statusCode: StatusCode;
+}
+
+export class ContinuationPointManager {
+    private readonly _map: any;
+
+    constructor() {
+        this._map = {};
+    }
+
+    /**
+     * returns true if the current number of active continuation point has reach the limit
+     * specified in maxBrowseContinuationPoint
+     * @param maxBrowseContinuationPoint
+     */
+    public hasReachMaximum(maxBrowseContinuationPoint: number): boolean {
+        if (maxBrowseContinuationPoint === 0) {
+            return false;
+        }
+        const nbContinuationPoints = Object.keys(this._map).length;
+        return nbContinuationPoints >= maxBrowseContinuationPoint;
+    }
+
+    public register(maxElements: number, values: ReferenceDescription[]): ContinuationPointInfo {
+        maxElements = maxElements || values.length;
+        if (maxElements >= values.length) {
+            return {
+                continuationPoint: undefined,
+                references: values,
+                statusCode: StatusCodes.Good
+            };
+        }
+
+        const key = make_key();
+        const keyHash = key.toString("ascii");
+
+        // split the array in two ( values)
+        const current_block = values.splice(0, maxElements);
+
+        const result = {
+            continuationPoint: key,
+            references: current_block,
+            statusCode: StatusCodes.Good
+        };
+
+        // create
+        const data = {
+            maxElements,
+            remainingElements: values
+        };
+        this._map[keyHash] = data;
+
+        return result;
+    }
+
+    public getNext(continuationPoint: ContinuationPoint): ContinuationPointInfo {
+        if (!continuationPoint) {
+            return { statusCode: StatusCodes.BadContinuationPointInvalid };
+        }
+        const keyHash = continuationPoint.toString("ascii");
+
+        const data = this._map[keyHash];
+        if (!data) {
+            return { statusCode: StatusCodes.BadContinuationPointInvalid };
+        }
+        assert(data.maxElements > 0);
+        // split the array in two ( values)
+        const current_block = data.remainingElements.splice(0, data.maxElements);
+
+        const result = {
+            continuationPoint: data.remainingElements.length ? continuationPoint : undefined,
+            references: current_block,
+            statusCode: StatusCodes.Good
+        };
+        if (data.remainingElements.length === 0) {
+            // we are done
+            delete this._map[keyHash];
+        }
+        return result;
+    }
+
+    public cancel(continuationPoint: ContinuationPoint): ContinuationPointInfo {
+        if (!continuationPoint) {
+            return { statusCode: StatusCodes.BadContinuationPointInvalid };
+        }
+
+        const keyHash = continuationPoint.toString("ascii");
+
+        const data = this._map[keyHash];
+        if (!data) {
+            return {
+                continuationPoint: undefined, // nullBuffer,
+                references: [],
+                statusCode: StatusCodes.BadContinuationPointInvalid
+            };
+        }
+        delete this._map[keyHash];
+        return {
+            statusCode: StatusCodes.Good
+        };
+    }
+}

package/source/helpers/adjust_browse_direction.ts

@@ -0,0 +1,15 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { BrowseDirection } from "node-opcua-data-model";
+
+export function adjustBrowseDirection(
+  browseDirection: BrowseDirection | null | undefined,
+  defaultValue: BrowseDirection
+):BrowseDirection  {
+    // istanbul ignore next
+    if (browseDirection === null || browseDirection === undefined) {
+        return defaultValue;
+    }
+    return browseDirection;
+}

package/source/helpers/argument_list.ts

@@ -0,0 +1,286 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import * as ec from "node-opcua-basic-types";
+import { BinaryStream, BinaryStreamSizeCalculator, OutputBinaryStream } from "node-opcua-binary-stream";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
+import * as factories from "node-opcua-factory";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { Argument } from "node-opcua-service-call";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { Variant } from "node-opcua-variant";
+import { DataType } from "node-opcua-variant";
+import { VariantArrayType } from "node-opcua-variant";
+
+import { NodeClass } from "node-opcua-data-model";
+import { IAddressSpace, UAMethod, UAObject } from "node-opcua-address-space-base";
+
+const debugLog = make_debugLog(__filename);
+const warningLog = make_warningLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+
+function myfindBuiltInType(dataType: DataType): any {
+    return factories.findBuiltInType(DataType[dataType]);
+}
+export interface ArgumentDef {
+    dataType: DataType
+    valueRank?: undefined | number;
+}
+export function encode_ArgumentList(definition: ArgumentDef[], args: any[], stream: OutputBinaryStream): void {
+    assert(definition.length === args.length);
+
+    assert(Array.isArray(definition));
+    assert(Array.isArray(args));
+    assert(definition.length === args.length);
+    assert(definition.length >= 0);
+
+    // we only encode arguments by following the definition
+
+    for (let i = 0; i < definition.length; i++) {
+        const def = definition[i];
+        const value = args[i];
+
+        const encodeFunc = myfindBuiltInType(def.dataType).encode;
+        // assert((def.valueRank === -1) || (def.valueRank === 0));
+
+        // todo : handle -3 -2
+        const isArray = def.valueRank && (def.valueRank === 1 || def.valueRank !== -1);
+
+        if (isArray) {
+            ec.encodeArray(value, stream, encodeFunc);
+        } else {
+            encodeFunc(value, stream);
+        }
+    }
+}
+
+export function decode_ArgumentList(definition: ArgumentDef[], stream: BinaryStream): any[] {
+    if (!Array.isArray(definition)) {
+        throw new Error(
+            "This BaseDataType cannot be decoded because it has no definition.\n" +
+                "Please construct a BaseDataType({definition : [{dataType: DataType.UInt32 }]});"
+        );
+    }
+
+    const args: any[] = [];
+    let value;
+
+    for (const def of definition) {
+        const decodeFunc = myfindBuiltInType(def.dataType).decode;
+
+        // xx assert(def.valueRank === -1 || def.valueRank==0);
+        const isArray = def.valueRank === 1 || def.valueRank === -1;
+
+        if (isArray) {
+            value = ec.decodeArray(stream, decodeFunc);
+        } else {
+            value = decodeFunc(stream);
+        }
+        args.push(value);
+    }
+    return args;
+}
+
+export function binaryStoreSize_ArgumentList(description: ArgumentDef[], args: any[]): number {
+    assert(Array.isArray(description));
+    assert(Array.isArray(args));
+    assert(args.length === description.length);
+
+    const stream = new BinaryStreamSizeCalculator();
+    encode_ArgumentList(description, args, stream);
+    return stream.length;
+}
+
+export function getMethodDeclaration_ArgumentList(
+    addressSpace: IAddressSpace,
+    objectId: NodeId,
+    methodId: NodeId
+): { statusCode: StatusCode; methodDeclaration?: UAMethod } {
+    // find object in address space
+    const obj = addressSpace.findNode(objectId) as UAObject;
+    if (!obj) {
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog("cannot find node ", objectId.toString());
+        }
+        return { statusCode: StatusCodes.BadNodeIdUnknown };
+    }
+    let objectMethod = obj.getMethodById(methodId) as UAMethod;
+    if (!objectMethod) {
+        // the method doesn't belong to the object, nevertheless
+        // the method can be called
+        objectMethod = addressSpace.findNode(methodId) as UAMethod;
+        if (!objectMethod || objectMethod.nodeClass !== NodeClass.Method) {
+            warningLog("cannot find method with id", methodId.toString(), "object Id = ", objectId.toString());
+            return { statusCode: StatusCodes.BadMethodInvalid };
+        }
+    }
+
+    const methodDeclarationId = objectMethod.methodDeclarationId;
+    const methodDeclaration = addressSpace.findNode(methodDeclarationId) as UAMethod;
+    if (!methodDeclaration) {
+        //  return {statusCode: StatusCodes.BadMethodInvalid};
+        return { statusCode: StatusCodes.Good, methodDeclaration: objectMethod };
+    }
+    // istanbul ignore next
+    if (methodDeclaration.nodeClass !== NodeClass.Method) {
+        throw new Error("Expecting a Method here");
+    }
+    return { statusCode: StatusCodes.Good, methodDeclaration };
+}
+
+/**
+ * @private
+ */
+function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argument, arg: Variant): boolean {
+    assert(Object.prototype.hasOwnProperty.call(argDefinition, "dataType"));
+    assert(Object.prototype.hasOwnProperty.call(argDefinition, "valueRank"));
+
+    const argDefDataType = addressSpace.findDataType(argDefinition.dataType);
+    const argDataType = addressSpace.findDataType(resolveNodeId(arg.dataType));
+
+    // istanbul ignore next
+    if (!argDefDataType) {
+        debugLog("dataType ", argDefinition.dataType.toString(), "doesn't exist");
+        return false;
+    }
+
+    if (argDefinition.valueRank > 0 && arg.dataType === DataType.Null) {
+        // this is valid to receive an empty array ith DataType.Null;
+        return true;
+    }
+
+    // istanbul ignore next
+    if (!argDataType) {
+        debugLog(" cannot find dataType ", arg.dataType, resolveNodeId(arg.dataType));
+        debugLog(" arg = ", arg.toString());
+        debugLog(" def =", argDefinition.toString());
+        return false;
+    }
+
+    // istanbul ignore next
+    if (doDebug) {
+        debugLog(" checking argDefDataType ", argDefDataType.toString());
+        debugLog(" checking argDataType ", argDataType.toString());
+    }
+
+    const isArray = arg.arrayType === VariantArrayType.Array;
+
+    if (argDefinition.valueRank > 0) {
+        return isArray;
+    } else if (argDefinition.valueRank === -1) {
+        // SCALAR
+        if (isArray) {
+            return false;
+        }
+    }
+
+    if (argDataType.nodeId.value === argDefDataType!.nodeId.value) {
+        return true;
+    }
+
+    // check that dataType is of the same type (derived )
+    return argDefDataType.isSupertypeOf(argDataType);
+}
+
+/**
+ * @method verifyArguments_ArgumentList
+ * @param addressSpace
+ * @param methodInputArguments
+ * @param inputArguments
+ * @return statusCode,inputArgumentResults
+ */
+export function verifyArguments_ArgumentList(
+    addressSpace: IAddressSpace,
+    methodInputArguments: Argument[],
+    inputArguments?: Variant[]
+): {
+    inputArgumentResults?: StatusCode[];
+    statusCode: StatusCode;
+} {
+    if (!inputArguments) {
+        // it is possible to not provide inputArguments when method  has no arguments
+        return methodInputArguments.length === 0
+            ? { statusCode: StatusCodes.Good }
+            : { statusCode: StatusCodes.BadArgumentsMissing };
+    }
+
+    const inputArgumentResults: StatusCode[] = methodInputArguments.map((methodInputArgument, index) => {
+        const argument = inputArguments![index];
+        if (!argument) {
+            return StatusCodes.BadNoData;
+        } else if (!isArgumentValid(addressSpace, methodInputArgument, argument)) {
+            return StatusCodes.BadTypeMismatch;
+        } else {
+            return StatusCodes.Good;
+        }
+    });
+
+    if (methodInputArguments.length > inputArguments.length) {
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog(
+                "verifyArguments_ArgumentList " +
+                    "\n       The client did  specify too many input arguments for the method.  " +
+                    "\n        expected : " +
+                    methodInputArguments.length +
+                    "" +
+                    "\n        actual   : " +
+                    inputArguments.length
+            );
+        }
+        return { inputArgumentResults, statusCode: StatusCodes.BadArgumentsMissing };
+    }
+
+    if (methodInputArguments.length < inputArguments.length) {
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog(
+                " verifyArguments_ArgumentList " +
+                    "\n        The client did not specify all of the input arguments for the method. " +
+                    "\n        expected : " +
+                    methodInputArguments.length +
+                    "" +
+                    "\n        actual   : " +
+                    inputArguments.length
+            );
+        }
+        return { inputArgumentResults, statusCode: StatusCodes.BadTooManyArguments };
+    }
+
+    return {
+        inputArgumentResults,
+        statusCode:
+            inputArgumentResults.includes(StatusCodes.BadTypeMismatch) || inputArgumentResults.includes(StatusCodes.BadOutOfRange)
+                ? StatusCodes.BadInvalidArgument
+                : StatusCodes.Good
+    };
+}
+
+export function build_retrieveInputArgumentsDefinition(
+    addressSpace: IAddressSpace
+): (objectId: NodeId, methodId: NodeId) => Argument[] {
+    const the_address_space = addressSpace;
+    return (objectId: NodeId, methodId: NodeId) => {
+        const response = getMethodDeclaration_ArgumentList(the_address_space, objectId, methodId);
+
+        /* istanbul ignore next */
+        if (response.statusCode !== StatusCodes.Good) {
+            debugLog(" StatusCode  = " + response.statusCode.toString());
+            throw new Error(
+                "Invalid Method " +
+                    response.statusCode.toString() +
+                    " ObjectId= " +
+                    objectId.toString() +
+                    "Method Id =" +
+                    methodId.toString()
+            );
+        }
+        const methodDeclaration = response.methodDeclaration!;
+        // verify input Parameters
+        const methodInputArguments = methodDeclaration.getInputArguments();
+        assert(Array.isArray(methodInputArguments));
+        return methodInputArguments;
+    };
+}

package/source/helpers/call_helpers.ts

@@ -0,0 +1,112 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { CallMethodRequest } from "node-opcua-service-call";
+import { StatusCodes } from "node-opcua-status-code";
+import { CallMethodResultOptions } from "node-opcua-types";
+import { Variant } from "node-opcua-variant";
+import { ISessionContext, IAddressSpace, UAMethod, UAObject } from "node-opcua-address-space-base";
+
+import { getMethodDeclaration_ArgumentList, verifyArguments_ArgumentList } from "./argument_list";
+import { resolveOpaqueOnAddressSpace } from "./resolve_opaque_on_address_space";
+
+// Symbolic Id                   Description
+// ----------------------------  -----------------------------------------------------------------------------
+// BadNodeIdInvalid              Used to indicate that the specified object is not valid.
+//
+// BadNodeIdUnknown             Used to indicate that the specified object is not valid.
+//
+// BadArgumentsMissing          The client did not specify all of the input arguments for the method.
+// BadUserAccessDenied
+//
+// BadMethodInvalid             The method id does not refer to a method for the specified object.
+// BadOutOfRange                Used to indicate that an input argument is outside the acceptable range.
+// BadTypeMismatch              Used to indicate that an input argument does not have the correct data type.
+//                               A ByteString is structurally the same as a one dimensional array of Byte.
+//                               A server shall accept a ByteString if an array of Byte is expected.
+// BadNoCommunication
+type ResponseCallback<T> = (err: Error | null, result?: T) => void;
+
+
+export function callMethodHelper(
+    context: ISessionContext,
+    addressSpace: IAddressSpace,
+    callMethodRequest: CallMethodRequest,
+    callback: ResponseCallback<CallMethodResultOptions>
+): void {
+    const objectId = callMethodRequest.objectId;
+    const methodId = callMethodRequest.methodId;
+    const inputArguments = callMethodRequest.inputArguments || [];
+
+    assert(objectId instanceof NodeId);
+    assert(methodId instanceof NodeId);
+
+    const object = addressSpace.findNode(objectId) as UAObject;
+    if (!object) {
+        return callback(null, { statusCode: StatusCodes.BadNodeIdUnknown });
+    }
+    if (object.nodeClass !== NodeClass.Object && object.nodeClass !== NodeClass.ObjectType) {
+        return callback(null, { statusCode: StatusCodes.BadNodeIdInvalid });
+    }
+
+    const methodObj = addressSpace.findNode(methodId) as UAMethod;
+    if (!methodObj) {
+        return callback(null, { statusCode: StatusCodes.BadNodeIdUnknown });
+    }
+    if (methodObj.nodeClass !== NodeClass.Method) {
+        return callback(null, { statusCode: StatusCodes.BadNodeIdInvalid });
+    }
+
+    const response1 = getMethodDeclaration_ArgumentList(addressSpace, objectId, methodId);
+
+    if (response1.statusCode !== StatusCodes.Good) {
+        return callback(null, { statusCode: response1.statusCode });
+    }
+    const methodDeclaration = response1.methodDeclaration!;
+
+    // verify input Parameters
+    const methodInputArguments = methodDeclaration.getInputArguments();
+
+    const response = verifyArguments_ArgumentList(addressSpace, methodInputArguments, inputArguments);
+    if (response.statusCode !== StatusCodes.Good) {
+        return callback(null, response);
+    }
+
+    resolveOpaqueOnAddressSpace(addressSpace, inputArguments)
+        .then(() => {
+            methodObj.execute(
+                object,
+                inputArguments,
+                context,
+                (err: Error | null, callMethodResponse?: CallMethodResultOptions) => {
+                    /* istanbul ignore next */
+                    if (err) {
+                        return callback(err);
+                    }
+                    if (!callMethodResponse) {
+                        return callback(new Error("internal Error"));
+                    }
+
+                    callMethodResponse.inputArgumentResults =
+                        callMethodResponse.inputArgumentResults || response.inputArgumentResults || [];
+                    assert(callMethodResponse.statusCode);
+
+                    if (callMethodResponse.statusCode === StatusCodes.Good) {
+                        assert(Array.isArray(callMethodResponse.outputArguments));
+                    }
+
+                    assert(Array.isArray(callMethodResponse.inputArgumentResults));
+                    assert(callMethodResponse.inputArgumentResults!.length === methodInputArguments.length);
+
+                    const outputArguments = callMethodResponse.outputArguments || [];
+                    resolveOpaqueOnAddressSpace(addressSpace, outputArguments as Variant[])
+                        .then(() => callback(null, callMethodResponse))
+                        .catch(callback);
+                }
+            );
+        })
+        .catch((err) => callback(err));
+}

package/source/helpers/check_event_clause.ts

@@ -0,0 +1,62 @@
+/**
+ * @module node-opcua-address-space
+ */
+// tslint:disable:no-console
+import { NodeClass } from "node-opcua-data-model";
+import { SimpleAttributeOperand } from "node-opcua-service-filter";
+import { constructBrowsePathFromQualifiedName } from "node-opcua-service-translate-browse-path";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { BaseNode, UAObjectType } from "node-opcua-address-space-base";
+
+/**
+ * @method checkSelectClause
+ * @param parentNode
+ * @param selectClause
+ * @return {Array<StatusCode>}
+ */
+export function checkSelectClause(
+  parentNode: BaseNode,
+  selectClause: SimpleAttributeOperand
+): StatusCode {
+    //
+    const addressSpace = parentNode.addressSpace;
+
+    // istanbul ignore next
+    if (selectClause.typeDefinitionId.isEmpty()) {
+        return StatusCodes.Good;
+    }
+    const eventTypeNode = addressSpace.findEventType(selectClause.typeDefinitionId)!;
+
+    if (!eventTypeNode || !(eventTypeNode.nodeClass === NodeClass.ObjectType)) {
+        // xx console.log("eventTypeNode = ",selectClause.typeDefinitionId.toString());
+        // xx console.log("eventTypeNode = ",eventTypeNode);
+        // istanbul ignore next
+        if (eventTypeNode) {
+            console.log(eventTypeNode.toString());
+        }
+    }
+
+    // istanbul ignore next
+    if (eventTypeNode.nodeClass !== NodeClass.ObjectType) {
+        throw new Error("Expecting a ObjectType");
+    }
+
+    // navigate to the innerNode specified by the browsePath [ QualifiedName]
+    const browsePath = constructBrowsePathFromQualifiedName(eventTypeNode, selectClause.browsePath);
+    const browsePathResult = addressSpace.browsePath(browsePath);
+    return browsePathResult.statusCode;
+
+}
+
+/**
+ * @method checkSelectClauses
+ * @param eventTypeNode
+ * @param selectClauses
+ * @return an array of StatusCode
+ */
+export function checkSelectClauses(
+  eventTypeNode: UAObjectType,
+  selectClauses: SimpleAttributeOperand[]
+): StatusCode[] {
+    return selectClauses.map(checkSelectClause.bind(null, eventTypeNode));
+}

package/source/helpers/coerce_enum_value.ts

@@ -0,0 +1,33 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import { Int64 } from "node-opcua-basic-types";
+import { coerceLocalizedText } from "node-opcua-data-model";
+import { EnumValueType } from "node-opcua-types";
+import { EnumValueTypeOptionsLike } from "../address_space_ts";
+
+export function coerceEnumValues(enumValues: EnumValueTypeOptionsLike[] | { [key: string]: number| Int64 }): EnumValueType[] {
+    if (Array.isArray(enumValues)) {
+        //
+        return enumValues.map((en: any) => {
+            assert(Object.prototype.hasOwnProperty.call(en,"value"));
+            assert(Object.prototype.hasOwnProperty.call(en,"displayName"));
+            return new EnumValueType({
+                displayName: coerceLocalizedText(en.displayName),
+                value: en.value
+            });
+        });
+    } else {
+        return coerceEnumValues(
+            Object.entries(enumValues as { [key: string]: Int64 }).map((entrie: [string, Int64]) => {
+                const [key, value] = entrie;
+                return new EnumValueType({
+                    description: coerceLocalizedText(key),
+                    displayName: coerceLocalizedText(key),
+                    value
+                });
+            })
+        );
+    }
+}