node-opcua-address-space 2.51.0

package/source/loader/namespace_post_step.ts

@@ -0,0 +1,36 @@
+import { NodeClass } from "node-opcua-data-model";
+import { make_debugLog, checkDebugFlag } from "node-opcua-debug";
+
+import { UAObject, UAVariable, IAddressSpace, INamespace } from "node-opcua-address-space-base";
+import { NamespacePrivate } from "../../src/namespace_private";
+
+
+const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+
+export const g_promotableObject: { [key: string]: (node: any) => any } = {};
+
+export async function promoteObjectAndVariablesInNamespace(namespace: INamespace): Promise<void> {
+    const namespaceP = namespace as NamespacePrivate;
+    for (const a of namespaceP.nodeIterator()) {
+        if (a.nodeClass === NodeClass.Object || a.nodeClass === NodeClass.Variable) {
+            const aa = a as (UAObject | UAVariable);
+            if (aa.typeDefinition) {
+                const promoter = g_promotableObject[aa.typeDefinition.toString()];
+                if (promoter) {
+                    const before = a.constructor.name;
+                    promoter(a as UAObject | UAVariable);
+                    const after = a.constructor.name;
+                    if (doDebug) {
+                        debugLog(`promoting ${a.browseName.toString()} from ${before} to ${after}`);
+                    }
+                }
+            }
+        }
+    }
+}
+export async function promoteObjectsAndVariables(addressSpace: IAddressSpace): Promise<void> {
+    for (const namespace of addressSpace.getNamespaceArray()) {
+        promoteObjectAndVariablesInNamespace(namespace);
+    }
+}

package/source/loader/register_node_promoter.ts

@@ -0,0 +1,8 @@
+import { NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
+import { UAObject, UAVariable } from "node-opcua-address-space-base";
+
+import { g_promotableObject } from "./namespace_post_step";
+
+export function registerNodePromoter(nodeId: NodeIdLike, promoter: ((node: UAVariable) => void) | ((node: UAObject) => void)): void {
+    g_promotableObject[resolveNodeId(nodeId).toString()] = promoter;
+}

package/source/namespace.ts

@@ -0,0 +1,9 @@
+import { INamespace } from "node-opcua-address-space-base";
+
+import { INamespaceAlarmAndCondition} from "./namespace_alarm_and_condition";
+import { INamespaceDataAccess} from "./namespace_data_access";
+import { INamespaceMachineState} from "./namespace_machine_state";
+
+export interface Namespace extends INamespace, INamespaceAlarmAndCondition , INamespaceDataAccess, INamespaceMachineState {
+    
+}

package/source/namespace_alarm_and_condition.ts

@@ -0,0 +1,47 @@
+import { UAEventType } from "node-opcua-address-space-base";
+import { NodeId } from "node-opcua-nodeid";
+import { UAAcknowledgeableConditionEx } from "../src/alarms_and_conditions/ua_acknowledgeable_condition_impl";
+import { UAAlarmConditionEx } from "../src/alarms_and_conditions/ua_alarm_condition_impl";
+import { UAConditionEx } from "../src/alarms_and_conditions/ua_condition_impl";
+import { UADiscreteAlarmEx } from "../src/alarms_and_conditions/ua_discrete_alarm_impl";
+import { UAExclusiveDeviationAlarmEx } from "../src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
+import { UAExclusiveLimitAlarmEx } from "../src/alarms_and_conditions/ua_exclusive_limit_alarm_impl";
+import { UALimitAlarmEx } from "../src/alarms_and_conditions/ua_limit_alarm_impl";
+import { UANonExclusiveDeviationAlarmEx } from "../src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
+import { UANonExclusiveLimitAlarmEx } from "../src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
+import { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
+
+export interface INamespaceAlarmAndCondition {
+    // --- Alarms & Conditions -------------------------------------------------
+    instantiateCondition(conditionTypeId: UAEventType | NodeId | string, options: any, data?: any): UAConditionEx;
+
+    instantiateAcknowledgeableCondition(
+        conditionTypeId: UAEventType | NodeId | string,
+        options: any,
+        data?: any
+    ): UAAcknowledgeableConditionEx;
+
+    instantiateAlarmCondition(alarmConditionTypeId: UAEventType | NodeId | string, options: any, data?: any): UAAlarmConditionEx;
+
+    instantiateLimitAlarm(limitAlarmTypeId: UAEventType | NodeId | string, options: any, data?: any): UALimitAlarmEx;
+
+    instantiateExclusiveLimitAlarm(
+        exclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
+        options: any,
+        data?: any
+    ): UAExclusiveLimitAlarmEx;
+
+    instantiateExclusiveDeviationAlarm(options: any, data?: any): UAExclusiveDeviationAlarmEx;
+
+    instantiateNonExclusiveLimitAlarm(
+        nonExclusiveLimitAlarmTypeId: UAEventType | NodeId | string,
+        options: any,
+        data?: any
+    ): UANonExclusiveLimitAlarmEx;
+
+    instantiateNonExclusiveDeviationAlarm(options: any, data?: any): UANonExclusiveDeviationAlarmEx;
+
+    instantiateDiscreteAlarm(discreteAlarmType: UAEventType | NodeId | string, options: any, data?: any): UADiscreteAlarmEx;
+
+    instantiateOffNormalAlarm(options: any, data?: any): UAOffNormalAlarmEx;
+}

package/source/namespace_data_access.ts

@@ -0,0 +1,60 @@
+import { AddVariableOptionsWithoutValue, AddYArrayItemOptions, BindVariableOptions } from "node-opcua-address-space-base";
+import { NodeIdLike } from "node-opcua-nodeid";
+import { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
+import { EUInformation, EUInformationOptions } from "node-opcua-types";
+import { DataType, VariantArrayType } from "node-opcua-variant";
+
+import { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
+import { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
+import { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
+import {
+    AddMultiStateDiscreteOptions,
+    AddMultiStateValueDiscreteOptions,
+    AddTwoStateDiscreteOptions,
+    AddTwoStateVariableOptions
+} from "./address_space_ts";
+import { UATwoStateVariableEx } from "./ua_two_state_variable_ex";
+import { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
+
+export interface AddDataItemOptions extends AddVariableOptionsWithoutValue {
+    arrayType?: VariantArrayType;
+    value?: BindVariableOptions;
+
+    /** @example  "(tempA -25) + tempB" */
+    definition?: string;
+    /** @example 0.5 */
+    valuePrecision?: number;
+}
+
+export interface AddAnalogDataItemOptions extends AddDataItemOptions {
+    value?: BindVariableOptions;
+
+    engineeringUnitsRange?: {
+        low: number;
+        high: number;
+    };
+    instrumentRange?: {
+        low: number;
+        high: number;
+    };
+    engineeringUnits?: EUInformationOptions | EUInformation;
+    minimumSamplingInterval?: number;
+    dataType?: string | NodeIdLike;
+}
+
+export interface INamespaceDataAccess {
+    addDataItem<T, DT extends DataType>(options: AddDataItemOptions): UADataItem<T, DT>;
+    addAnalogDataItem<T, DT extends DataType>(options: AddAnalogDataItemOptions): UAAnalogItem<T, DT>;
+
+    addYArrayItem<DT extends DataType.Double | DataType.Float>(options: AddYArrayItemOptions): UAYArrayItemEx<DT>;
+
+    addTwoStateVariable(options: AddTwoStateVariableOptions): UATwoStateVariableEx;
+
+    addTwoStateDiscrete(options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx;
+
+    addMultiStateDiscrete<T, DT extends DataType>(options: AddMultiStateDiscreteOptions): UAMultiStateDiscreteEx<T, DT>;
+
+    addMultiStateValueDiscrete<T, DT extends DataType>(
+        options: AddMultiStateValueDiscreteOptions
+    ): UAMultiStateValueDiscreteEx<T, DT>;
+}

package/source/namespace_machine_state.ts

@@ -0,0 +1,13 @@
+import { UAObject, UAObjectType } from "node-opcua-address-space-base";
+import { UAState } from "node-opcua-nodeset-ua";
+import { UATransitionEx } from "./interfaces/state_machine/ua_transition_ex";
+export interface INamespaceMachineState {
+    addState(component: UAObject | UAObjectType, stateName: string, stateNumber: number, isInitialState?: boolean): UAState;
+    addTransition(
+        component: UAObject | UAObjectType,/* StateMachine | StateMachineType,*/
+        fromState: string,
+        toState: string,
+        transitionNumber: number
+    ): UATransitionEx;
+}
+

package/source/pseudo_session.ts

@@ -0,0 +1,288 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { promisify } from "util";
+import * as async from "async";
+
+import { assert } from "node-opcua-assert";
+import { DataValue } from "node-opcua-data-value";
+import { make_errorLog } from "node-opcua-debug";
+import { NodeId, resolveNodeId, NodeIdType } from "node-opcua-nodeid";
+import {
+    ArgumentDefinition,
+    BrowseDescriptionLike,
+    CallMethodRequestLike,
+    getArgumentDefinitionHelper,
+    IBasicSession,
+    MethodId,
+    ResponseCallback
+} from "node-opcua-pseudo-session";
+import { BrowseDescription, BrowseResult } from "node-opcua-service-browse";
+import { CallMethodRequest, CallMethodResult, CallMethodResultOptions } from "node-opcua-service-call";
+import { BrowsePath, BrowsePathResult } from "node-opcua-service-translate-browse-path";
+import { StatusCodes, StatusCode } from "node-opcua-status-code";
+import { NodeClass, AttributeIds } from "node-opcua-data-model";
+import { WriteValueOptions, ReadValueIdOptions, BrowseDescriptionOptions } from "node-opcua-types";
+import { randomGuid } from "node-opcua-basic-types";
+
+import { IAddressSpace, UAVariable, ISessionContext } from "node-opcua-address-space-base";
+
+import { ContinuationPointManager } from "./continuation_points/continuation_point_manager";
+import { callMethodHelper } from "./helpers/call_helpers";
+import { SessionContext } from "./session_context";
+
+const errorLog = make_errorLog("PseudoSession");
+/**
+ * Pseudo session is an helper object that exposes the same async methods
+ * than the ClientSession. It can be used on a server address space.
+ *
+ * Code reused !
+ * The primary benefit of this object  is that its makes advanced OPCUA
+ * operations that uses browse, translate, read, write etc similar
+ * whether we work inside a server or through a client session.
+ *
+ */
+export class PseudoSession implements IBasicSession {
+    public requestedMaxReferencesPerNode = 0;
+    private _sessionId: NodeId = new NodeId(NodeIdType.GUID, randomGuid());
+    private readonly addressSpace: IAddressSpace;
+    private readonly continuationPointManager: ContinuationPointManager;
+    private readonly context: ISessionContext;
+
+    constructor(addressSpace: IAddressSpace, context?: ISessionContext) {
+        this.addressSpace = addressSpace;
+        this.context = context || SessionContext.defaultContext;
+        this.continuationPointManager = new ContinuationPointManager();
+    }
+
+    public getSessionId(): NodeId {
+        return this._sessionId;
+    }
+    public browse(nodeToBrowse: BrowseDescriptionLike, callback: ResponseCallback<BrowseResult>): void;
+    public browse(nodesToBrowse: BrowseDescriptionLike[], callback: ResponseCallback<BrowseResult[]>): void;
+    public browse(nodeToBrowse: BrowseDescriptionLike): Promise<BrowseResult>;
+    public browse(nodesToBrowse: BrowseDescriptionLike[]): Promise<BrowseResult[]>;
+    public browse(nodesToBrowse: BrowseDescriptionLike | BrowseDescriptionLike[], callback?: ResponseCallback<any>): any {
+        setImmediate(() => {
+            const isArray = Array.isArray(nodesToBrowse);
+            if (!isArray) {
+                nodesToBrowse = [nodesToBrowse as BrowseDescriptionLike];
+            }
+            let results: BrowseResult[] = [];
+            for (const browseDescription of nodesToBrowse as BrowseDescriptionOptions[]) {
+                browseDescription.referenceTypeId = resolveNodeId(browseDescription.referenceTypeId!);
+                const _browseDescription =
+                    browseDescription instanceof BrowseDescription ? browseDescription : new BrowseDescription(browseDescription);
+                const nodeId = resolveNodeId(_browseDescription.nodeId);
+                const r = this.addressSpace.browseSingleNode(nodeId, _browseDescription, this.context);
+                results.push(r);
+            }
+
+            // handle continuation points
+            results = results.map((result: BrowseResult) => {
+                assert(!result.continuationPoint);
+                const truncatedResult = this.continuationPointManager.register(
+                    this.requestedMaxReferencesPerNode,
+                    result.references || []
+                );
+                assert(truncatedResult.statusCode === StatusCodes.Good);
+                truncatedResult.statusCode = result.statusCode;
+                return new BrowseResult(truncatedResult);
+            });
+            callback!(null, isArray ? results : results[0]);
+        });
+    }
+
+    public read(nodeToRead: ReadValueIdOptions, callback: ResponseCallback<DataValue>): void;
+    public read(nodesToRead: ReadValueIdOptions[], callback: ResponseCallback<DataValue[]>): void;
+    public read(nodeToRead: ReadValueIdOptions): Promise<DataValue>;
+    public read(nodesToRead: ReadValueIdOptions[]): Promise<DataValue[]>;
+    public read(nodesToRead: ReadValueIdOptions[] | ReadValueIdOptions, callback?: ResponseCallback<any>): any {
+        const isArray = Array.isArray(nodesToRead);
+        if (!isArray) {
+            nodesToRead = [nodesToRead as ReadValueIdOptions];
+        }
+        const _nodesToRead = nodesToRead as ReadValueIdOptions[];
+        const context = this.context;
+
+        setImmediate(() => {
+            async.map(
+                _nodesToRead,
+                (nodeToRead: ReadValueIdOptions, innerCallback: any) => {
+                    const obj = this.addressSpace.findNode(nodeToRead.nodeId!);
+                    if (!obj || obj.nodeClass !== NodeClass.Variable || nodeToRead.attributeId !== AttributeIds.Value) {
+                        return innerCallback();
+                    }
+                    (obj as UAVariable).readValueAsync(context, innerCallback);
+                },
+                (err) => {
+                    const dataValues = _nodesToRead.map((nodeToRead: ReadValueIdOptions) => {
+                        assert(!!nodeToRead.nodeId, "expecting a nodeId");
+                        assert(!!nodeToRead.attributeId, "expecting a attributeId");
+
+                        const nodeId = nodeToRead.nodeId!;
+                        const attributeId = nodeToRead.attributeId!;
+                        const indexRange = nodeToRead.indexRange;
+                        const dataEncoding = nodeToRead.dataEncoding;
+                        const obj = this.addressSpace.findNode(nodeId);
+                        if (!obj) {
+                            return new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown });
+                        }
+                        const context = this.context;
+                        const dataValue = obj.readAttribute(context, attributeId, indexRange, dataEncoding);
+                        return dataValue;
+                    });
+
+                    callback!(null, isArray ? dataValues : dataValues[0]);
+                }
+            );
+        });
+    }
+
+    public browseNext(
+        continuationPoint: Buffer,
+        releaseContinuationPoints: boolean,
+        callback: ResponseCallback<BrowseResult>
+    ): void;
+
+    public browseNext(
+        continuationPoints: Buffer[],
+        releaseContinuationPoints: boolean,
+        callback: ResponseCallback<BrowseResult[]>
+    ): void;
+
+    public browseNext(continuationPoint: Buffer, releaseContinuationPoints: boolean): Promise<BrowseResult>;
+
+    public browseNext(continuationPoints: Buffer[], releaseContinuationPoints: boolean): Promise<BrowseResult[]>;
+    public browseNext(continuationPoints: Buffer | Buffer[], releaseContinuationPoints: boolean, callback?: ResponseCallback<any>): any {
+        setImmediate(() => {
+            if (continuationPoints instanceof Buffer) {
+                return this.browseNext([continuationPoints], releaseContinuationPoints, (err, _results) => {
+                    if (err) {
+                        return callback!(err);
+                    }
+                    callback!(null, _results![0]);
+                });
+            }
+            let results: any;
+            if (releaseContinuationPoints) {
+                // releaseContinuationPoints = TRUE
+                //   passed continuationPoints shall be reset to free resources in
+                //   the Server. The continuation points are released and the results
+                //   and diagnosticInfos arrays are empty.
+                results = continuationPoints.map((continuationPoint: any) => {
+                    return this.continuationPointManager.cancel(continuationPoint);
+                });
+            } else {
+                // let extract data from continuation points
+
+                // releaseContinuationPoints = FALSE
+                //   passed continuationPoints shall be used to get the next set of
+                //   browse information.
+                results = continuationPoints.map((continuationPoint: any) => {
+                    return this.continuationPointManager.getNext(continuationPoint);
+                });
+            }
+            results = results.map((r: any) => new BrowseResult(r));
+
+            callback!(null, results);
+        });
+    }
+
+    // call service ----------------------------------------------------------------------------------------------------
+    public call(methodToCall: CallMethodRequestLike, callback: ResponseCallback<CallMethodResult>): void;
+    public call(methodsToCall: CallMethodRequestLike[], callback: ResponseCallback<CallMethodResult[]>): void;
+    public call(methodToCall: CallMethodRequestLike): Promise<CallMethodResult>;
+    public call(methodsToCall: CallMethodRequestLike[]): Promise<CallMethodResult[]>;
+    public call(methodsToCall: CallMethodRequestLike | CallMethodRequestLike[], callback?: ResponseCallback<any>): any {
+        const isArray = Array.isArray(methodsToCall);
+        if (!isArray) {
+            methodsToCall = [methodsToCall as CallMethodRequestLike];
+        }
+
+        async.map(
+            methodsToCall as CallMethodRequestLike[],
+            (methodToCall, innerCallback: (err: Error | null, result?: CallMethodResult) => void) => {
+                const callMethodRequest = new CallMethodRequest(methodToCall);
+
+                callMethodHelper(
+                    this.context,
+                    this.addressSpace,
+                    callMethodRequest,
+                    (err: Error | null, result?: CallMethodResultOptions) => {
+                        let callMethodResult: CallMethodResult;
+                        if (err) {
+                            errorLog("Internal Error = ", err);
+                            callMethodResult = new CallMethodResult({
+                                statusCode: StatusCodes.BadInternalError
+                            });
+                        } else {
+                            callMethodResult = new CallMethodResult(result);
+                        }
+                        innerCallback(null, callMethodResult);
+                    }
+                );
+            },
+            (err?: Error | null, callMethodResults?: any) => {
+                callback!(null, isArray ? callMethodResults! : callMethodResults![0]);
+            }
+        );
+    }
+
+    public getArgumentDefinition(methodId: MethodId): Promise<ArgumentDefinition>;
+    public getArgumentDefinition(methodId: MethodId, callback: ResponseCallback<ArgumentDefinition>): void;
+    public getArgumentDefinition(methodId: MethodId, callback?: ResponseCallback<ArgumentDefinition>): any {
+        return getArgumentDefinitionHelper(this, methodId, callback!);
+    }
+
+    public translateBrowsePath(browsePaths: BrowsePath[], callback: ResponseCallback<BrowsePathResult[]>): void;
+    public translateBrowsePath(browsePath: BrowsePath, callback: ResponseCallback<BrowsePathResult>): void;
+    public translateBrowsePath(browsePath: BrowsePath): Promise<BrowsePathResult>;
+    public translateBrowsePath(browsePaths: BrowsePath[]): Promise<BrowsePathResult[]>;
+    public translateBrowsePath(browsePaths: BrowsePath[] | BrowsePath, callback?: ResponseCallback<any>): any {
+        const isArray = Array.isArray(browsePaths);
+        if (!isArray) {
+            browsePaths = [browsePaths as BrowsePath];
+        }
+        const browsePathResults = (browsePaths as BrowsePath[]).map((browsePath: BrowsePath) => {
+            return this.addressSpace.browsePath(browsePath);
+        });
+        callback!(null, isArray ? browsePathResults : browsePathResults[0]);
+    }
+    public write(nodeToWrite: WriteValueOptions, callback: ResponseCallback<StatusCode>): void;
+    public write(nodesToWrite: WriteValueOptions[], callback: ResponseCallback<StatusCode[]>): void;
+    public write(nodeToWrite: WriteValueOptions): Promise<StatusCode>;
+    public write(nodesToWrite: WriteValueOptions[]): Promise<StatusCode[]>;
+    public write(nodesToWrite: WriteValueOptions[] | WriteValueOptions, callback?: ResponseCallback<any>): any {
+        const isArray = nodesToWrite instanceof Array;
+        const _nodesToWrite: WriteValueOptions[]  = !isArray ? [nodesToWrite]: nodesToWrite;
+        const context = this.context;
+        setImmediate(() => {
+            const statusCodesPromises = _nodesToWrite.map((nodeToWrite: WriteValueOptions) => {
+                assert(!!nodeToWrite.nodeId, "expecting a nodeId");
+                assert(!!nodeToWrite.attributeId, "expecting a attributeId");
+
+                const nodeId = nodeToWrite.nodeId!;
+                const obj = this.addressSpace.findNode(nodeId);
+                if (!obj) {
+                    return  StatusCodes.BadNodeIdUnknown;
+                }
+                return promisify(obj.writeAttribute).call(obj, context, nodeToWrite);
+            });
+            Promise.all(statusCodesPromises).then((statusCodes) => {
+                callback!(null, isArray ? statusCodes : statusCodes[0]);
+            });
+        });
+    }
+}
+
+// tslint:disable:no-var-requires
+// tslint:disable:max-line-length
+const thenify = require("thenify");
+PseudoSession.prototype.read = thenify.withCallback(PseudoSession.prototype.read);
+PseudoSession.prototype.write = thenify.withCallback(PseudoSession.prototype.write);
+PseudoSession.prototype.browse = thenify.withCallback(PseudoSession.prototype.browse);
+PseudoSession.prototype.browseNext = thenify.withCallback(PseudoSession.prototype.browseNext);
+PseudoSession.prototype.getArgumentDefinition = thenify.withCallback(PseudoSession.prototype.getArgumentDefinition);
+PseudoSession.prototype.call = thenify.withCallback(PseudoSession.prototype.call);
+PseudoSession.prototype.translateBrowsePath = thenify.withCallback(PseudoSession.prototype.translateBrowsePath);