packages\node-opcua-client-proxy\src\proxy.js

"use strict";
/**
 * @module opcua.client
 */
 
 
const async = require("async");
const assert = require("node-opcua-assert").assert;
const _ = require("underscore");
const util = require("util");
const EventEmitter = require("events").EventEmitter;
 
 
const read_service = require("node-opcua-service-read");
const call_service = require("node-opcua-service-call");
 
const AttributeIds = require("node-opcua-data-model").AttributeIds;
const AccessLevelFlag = require("node-opcua-data-model").AccessLevelFlag;
const makeResultMask = require("node-opcua-data-model").makeResultMask;
const BrowseDirection = require("node-opcua-data-model").BrowseDirection;
const NodeClass = require("node-opcua-data-model").NodeClass;
const makeNodeClassMask = require("node-opcua-data-model").makeNodeClassMask;
 
const ReferenceTypeIds = require("node-opcua-constants").ReferenceTypeIds;
const ObjectTypeIds = require("node-opcua-constants").ObjectTypeIds;
 
const NodeId = require("node-opcua-nodeid").NodeId;
const makeNodeId = require("node-opcua-nodeid").makeNodeId;
const coerceNodeId = require("node-opcua-nodeid").coerceNodeId;
 
const StatusCodes = require("node-opcua-status-code").StatusCodes;
 
const lowerFirstLetter = require("node-opcua-utils").lowerFirstLetter;
 
const Variant = require("node-opcua-variant").Variant;
const VariantArrayType = require("node-opcua-variant").VariantArrayType;
const DataType = require("node-opcua-variant").DataType;
 
 
const ClientSession = require("node-opcua-client").ClientSession;
const ClientSubscription = require("node-opcua-client").ClientSubscription;
 
const resultMask = makeResultMask("ReferenceType | IsForward | BrowseName | NodeClass | TypeDefinition");
 
function makeRefId(referenceTypeName) {
    const nodeId = makeNodeId(ReferenceTypeIds[referenceTypeName] || ObjectTypeIds[referenceTypeName]);
 
    // istanbul ignore next
    if (nodeId.isEmpty()) {
        throw new Error("makeRefId: cannot find ReferenceTypeName + ", referenceTypeName);
    }
    return nodeId;
}
 
exports.makeRefId = makeRefId;
 
/**
 * @method convertNodeIdToDataTypeAsync
 *
 * @param session             {ClientSession}
 * @param dataTypeId          {NodeId}
 * @param callback            {Function}
 * @param callback.err        {Error|null}
 * @param callback.dataType   {DataType}
 *
 *  @example
 *
 *      var dataTypeId  ="ns=0;i=11"; // Double
 *      convertNodeIdToDataTypeAsync(session,dataTypeId,function(err,dataType) {
 *          assert(!err && dataType === DataType.Double);
 *      });
 *
 *      var dataTypeId  ="ns=0;i=290"; // Duration => SubTypeOf Double
 *      convertNodeIdToDataTypeAsync(session,dataTypeId,function(err,dataType) {
 *          assert(!err && dataType === DataType.Double);
 *      });
 *
 * see also AddressSpace#findCorrespondingBasicDataType
 */
function convertNodeIdToDataTypeAsync(session, dataTypeId, callback) {
 
    const nodeToRead = {
        nodeId: dataTypeId,
        attributeId: AttributeIds.BrowseName
    };
 
    session.read(nodeToRead, function (err, dataValue) {
 
        // istanbul ignore next
        if (err) {
            return setImmediate(function(){callback(err);});
        }
 
        let dataType;
        // istanbul ignore next
        if (dataValue.statusCode !== StatusCodes.Good) {
            //Xx console.log("convertNodeIdToDataTypeAsync: Cannot read browse name for nodeID ".red + dataTypeId.toString());
            dataType = DataType.Null;
            return setImmediate(function(){callback(null, dataType);});
        }
 
        const dataTypeName = dataValue.value.value;
 
        if (dataTypeId.namespace === 0 && DataType.get(dataTypeId.value)) {
            dataType = DataType.get(dataTypeId.value);
            return setImmediate(function(){callback(null, dataType);});
        }
 
        /// example => Duration (i=290) => Double (i=11)
        // read subTypeOf
        const nodeToBrowse = {
            // BrowseDescription
            referenceTypeId: makeRefId("HasSubtype"),
            //xx nodeClassMask: makeNodeClassMask("ObjectType"),
            includeSubtypes: false,
            browseDirection: BrowseDirection.Inverse,
            nodeId: dataTypeId,
            resultMask: resultMask
        };
        session.browse(nodeToBrowse, function (err, browseResult) {
            // istanbul ignore next
            if (err) {
                return callback(err);
            }
 
            const references = browseResult.references;
 
            if (!references || references.length !== 1) {
                return callback(new Error("cannot find SuperType of " + dataTypeName.toString()));
            }
            const nodeId = references[0].nodeId;
            return convertNodeIdToDataTypeAsync(session, nodeId, callback);
        });
    });
}
 
function convertNodeIdToDataType(dataTypeId) {
    return dataTypeId._dataType;
}
 
function ProxyBaseNode(proxyManager, nodeId) {
 
    const self = this;
    /**
     * the object nodeId
     * @property nodeId
     * @type {NodeId}
     */
    self.nodeId = nodeId;
 
    self.proxyManager = proxyManager;
    assert(self.proxyManager.session, "expecting valid session");
    Object.defineProperty(self, "proxyManager", {
        enumerable: false,
        writable: true
    });
    /**
     * the object's components
     * @property $components
     * @type {Array<ProxyBaseNode>}
     */
    self.$components = [];
 
    /**
     * the object's properties
     * @property $properties
     * @type {Array<ProxyBaseNode>}
     */
    self.$properties = [];
 
    /**
     * the object's properties
     * @property $methods
     * @type {Array<ProxyBaseNode>}
     */
    self.$methods = [];
 
    /**
     * the Folder's elements
     * @property $organizes
     * @type {Array<ProxyBaseNode>}
     */
    self.$organizes = [];
 
    /**
     * the object's description
     * @property description
     * @type {String}
     */
    self.description = "";
    /**
     * the object's browseName
     * @property browseName
     * @type {String}
     */
    self.browseName = "";
    /**
     * the object's NodeClass
     * @property nodeClass
     * @type {NodeClass}
     */
    self.nodeClass = null;
}
 
util.inherits(ProxyBaseNode, EventEmitter);
 
 
/**
 * get a updated Value of the Variable , by using a ReadRequest
 * @method readValue
 * @param callback {Function}
 * @param callback.err {Error|null}
 * @param callback.dataValue {DataValue}
 */
ProxyBaseNode.prototype.readValue = function (callback) {
 
    const self = this;
    assert(self.proxyManager);
 
    const session = self.proxyManager.session;
    assert(session);
 
    const nodeToRead = {
        nodeId: self.nodeId,
        attributeId: AttributeIds.Value
    };
    self.proxyManager.session.read(nodeToRead, function (err, dataValue) {
 
        // istanbul ignore next
        if (err) {
            return callback(err);
        }
        const data = dataValue.value;
        callback(null, data);
 
    });
};
 
 
/**
 * set the Value of the Variable, by using a WriteRequest
 * @method writeValue
 * @param dataValue {DataValue}
 * @param callback {Function}
 * @param callback.err {Error|null}
 */
ProxyBaseNode.prototype.writeValue = function (dataValue, callback) {
    const self = this;
    assert(self.proxyManager);
 
    const session = self.proxyManager.session;
    assert(session);
 
    const nodeToWrite = {
        nodeId: self.nodeId,
        attributeId: AttributeIds.Value,
        value: dataValue
    };
    self.proxyManager.session.write(nodeToWrite, function (err, statusCode) {
        // istanbul ignore next
        if (err) {
            return callback(err);
        }
        if (statusCode !== StatusCodes.Good) {
            callback(new Error(statusCode.toString()));
        } else {
            callback(null);
        }
    });
};
 
ProxyBaseNode.prototype.toString = function () {
 
    const str = [];
    const self = this;
    str.push(" ProxyObject ");
    str.push("   browseName     : " + self.browseName.toString());
    str.push("   typeDefinition : " + self.typeDefinition.toString());
    str.push("   $components#   : " + self.$components.length.toString());
    str.push("   $properties#   : " + self.$properties.length.toString());
 
    return str.join("\n");
};
 
function ProxyVariable(session, nodeId) {
    ProxyBaseNode.apply(this, arguments);
}
 
util.inherits(ProxyVariable, ProxyBaseNode);
 
const ProxyObject = ProxyVariable;
 
function ObjectExplorer(options) {
    const self = this;
    self.proxyManager = options.proxyManager;
    self.name = options.name;
    self.nodeId = options.nodeId;
    self.parent = options.parent;
}
 
ObjectExplorer.prototype.$resolve = function (callback) {
 
    const self = this;
 
    self.proxyManager.getObject(self.nodeId, function (err, childObj) {
 
        // istanbul ignore next
        if (err) {
            return callback(err);
        }
 
        self.parent[self.name] = childObj;
        self.parent.$components.push(childObj);
 
        callback(null)
    });
};
 
function readUAStructure(proxyManager, obj, callback) {
 
    const session = proxyManager.session;
 
    //   0   Object
    //   1   Variable
    //   2   Method
    const nodeId = obj.nodeId;
    const nodesToBrowse = [
 
        // Components (except Methods)
        {
            // BrowseDescription
            referenceTypeId: makeRefId("HasComponent"),
            nodeClassMask: makeNodeClassMask("Object | Variable"), // we don't want Method here
            includeSubtypes: true,
            browseDirection: BrowseDirection.Forward,
            nodeId: nodeId,
            resultMask: resultMask
        },
        // Properties
        {
            // BrowseDescription
            referenceTypeId: makeRefId("HasProperty"),
            //nodeClassMask: makeNodeClassMask("Variable"),
            includeSubtypes: true,
            browseDirection: BrowseDirection.Forward,
            nodeId: nodeId,
            resultMask: resultMask
        },
 
        // Methods
        {
            // BrowseDescription
            referenceTypeId: makeRefId("HasComponent"),
            nodeClassMask: makeNodeClassMask("Method"),
            includeSubtypes: true,
            browseDirection: BrowseDirection.Forward,
            nodeId: nodeId,
            resultMask: resultMask
        },
        // TypeDefinition
        {
            // BrowseDescription
            referenceTypeId: makeRefId("HasTypeDefinition"),
            includeSubtypes: true,
            browseDirection: BrowseDirection.Both,
            nodeId: nodeId,
            resultMask: resultMask
 
        },
        // FromState
        {
            // BrowseDescription
            referenceTypeId: makeRefId("FromState"),
            includeSubtypes: true,
            browseDirection: BrowseDirection.Forward,
            nodeId: nodeId,
            resultMask: resultMask
        },
        // ToState
        {
            // BrowseDescription
            referenceTypeId: makeRefId("ToState"),
            includeSubtypes: true,
            browseDirection: BrowseDirection.Forward,
            nodeId: nodeId,
            resultMask: resultMask
        },
        // (for folders ) Organizes
        {
            // BrowseDescription
            referenceTypeId: makeRefId("Organizes"),
            includeSubtypes: true,
            browseDirection: BrowseDirection.Forward,
            nodeId: nodeId,
            resultMask: resultMask
        }
    ];
 
 
    /**
     * @method add_method
     * construct a callable method
     *
     * @param obj
     * @param reference
     * @param callback
     * @private
     */
    function add_method(obj, reference, callback) {
 
        const name = lowerFirstLetter(reference.browseName.name);
 
        obj[name] = function functionCaller(inputArgs, callback) {
 
            assert(_.isFunction(callback));
            // convert input arguments into Variants
            const inputArgsDef = obj[name].inputArguments || [];
 
            const inputArguments = inputArgsDef.map(function (arg) {
 
                const dataType = convertNodeIdToDataType(arg.dataType);
 
                const arrayType = (arg.valueRank === 1) ? VariantArrayType.Array : VariantArrayType.Scalar;
 
                //xx console.log("xxx ",arg.toString());
                const propName = lowerFirstLetter(arg.name);
 
                const value = inputArgs[propName];
                if (value === undefined) {
                    throw new Error("expecting input argument " + propName);
                }
                if (arrayType === VariantArrayType.Array) {
                    if (!_.isArray(value)) {
                        throw new Error("expecting value to be an Array or a TypedArray");
                    }
                }
 
                return new Variant({arrayType: arrayType, dataType: dataType, value: value});
            });
 
            const methodToCall = new call_service.CallMethodRequest({
                objectId: obj.nodeId,
                methodId: reference.nodeId,
                inputArguments: inputArguments
            });
 
            //xx console.log(" calling ",methodToCall.toString());
 
            session.call(methodToCall, function (err, callResult) {
 
                // istanbul ignore next
                if (err) {
                    return callback(err);
                }
                if (callResult.statusCode !== StatusCodes.Good) {
                    return callback(new Error("Error " + callResult.statusCode.toString()));
                }
                callResult.outputArguments = callResult.outputArguments || [];
 
                obj[name].outputArguments =  obj[name].outputArguments || [];
 
                assert(callResult.outputArguments.length === obj[name].outputArguments.length);
                const outputArgs = {};
 
                const outputArgsDef = obj[name].outputArguments;
 
                _.zip(outputArgsDef, callResult.outputArguments).forEach(function (pair) {
                    const arg = pair[0];
                    const variant = pair[1];
 
                    const propName = lowerFirstLetter(arg.name);
                    outputArgs[propName] = variant.value;
 
                });
                callback(err, outputArgs);
 
            });
        };
 
 
        function extractDataType(arg, callback) {
 
            if (arg.dataType && arg.dataType._dataType) {
                return setImmediate(callback); // already converted
            }
 
            convertNodeIdToDataTypeAsync(session, arg.dataType, function (err, dataType) {
                if (!err) {
                    assert(dataType.hasOwnProperty("value"));
                    arg.dataType._dataType = dataType;
                }
                callback(err);
            });
        }
 
        const methodObj = {
            nodeId: reference.nodeId,
            executableFlag: false,
            browseName: name,
            func: obj[name]
        };
        obj.$methods[name] = methodObj;
 
        async.parallel([
            function(callback) {
                session.getArgumentDefinition(reference.nodeId, function (err, args) {
                    // istanbul ignore next
                    if (err) {
                        return setImmediate(function() { callback(err); });
                    }
                    const inputArguments  = args.inputArguments;
                    const outputArguments = args.outputArguments;
 
                    obj[name].inputArguments = inputArguments;
                    obj[name].outputArguments = outputArguments;
 
                    async.series([
                        function (callback) {
                            async.each(obj[name].inputArguments, extractDataType, callback);
                        },
                        function (callback) {
                            async.each(obj[name].outputArguments, extractDataType, callback);
                        }
                    ], callback)
                });
            },
            function(callback) {
                proxyManager._monitor_execution_flag(methodObj, function () {
                    callback();
                });
            }
        ],callback);
 
    }
 
    function add_component(obj, reference, callback) {
 
        const name = lowerFirstLetter(reference.browseName.name || "");
 
        proxyManager.getObject(reference.nodeId, function (err, childObj) {
 
            // istanbul ignore else
            if (!err) {
                childObj = new ObjectExplorer({
                    proxyManager: proxyManager,
                    nodeId: reference.nodeId,
                    name: name,
                    parent: obj
                });
                obj[name] = childObj;
                obj.$components.push(childObj);
 
                childObj.$resolve(callback);
            } else {
                callback(err);
            }
        });
    }
 
    function addFolderElement(obj, reference, callback) {
 
        const name = lowerFirstLetter(reference.browseName.name || "");
 
        const childObj = new ObjectExplorer({
            proxyManager: proxyManager,
            nodeId: reference.nodeId,
            name: name,
            parent: obj
        });
        obj[name] = childObj;
        obj.$organizes.push(childObj);
        childObj.$resolve(callback);
    }
 
    function add_property(obj, reference, callback) {
 
        const name = lowerFirstLetter(reference.browseName.name || "");
 
        obj[name] = new ProxyVariable(proxyManager, reference.nodeId, reference);
        obj.$properties[name] = obj[name];
 
        setImmediate(callback);
    }
 
    function add_typeDefinition(obj, references, callback) {
        references = references || [];
        if (references.length !== 1) {
            //xx console.log(" cannot find type definition", references.length);
            return setImmediate(callback);
        }
        const reference = references[0];
        assert(!obj.typeDefinition, "type definition can only be set once");
        obj.typeDefinition = reference.browseName.name || "";
        setImmediate(callback);
    }
 
    function addFromState(obj, reference, callback) {
        proxyManager.getObject(reference.nodeId, function (err, childObj) {
            obj.$fromState = childObj;
            callback(err);
        });
    }
 
    function addToState(obj, reference, callback) {
        proxyManager.getObject(reference.nodeId, function (err, childObj) {
            obj.$toState = childObj;
            callback(err);
        });
    }
 
 
    session.browse(nodesToBrowse, function (err, browseResults) {
        function t(references) {
            return references.map(function (r) {
                return r.browseName.name + " " + r.nodeId.toString();
            });
        }
 
        // istanbul ignore next
        if (err) {
            return callback(err);
        }
 
        //xx console.log("Components", t(results[0].references));
        //xx console.log("Properties", t(results[1].references));
        //xx console.log("Methods", t(results[2].references));
        async.parallel([
 
            function (callback) {
                async.map(browseResults[0].references, add_component.bind(null, obj), callback);
            },
 
            function (callback) {
                async.map(browseResults[1].references, add_property.bind(null, obj), callback);
            },
 
            // now enrich our object with nice callable async methods
            function (callback) {
                async.map(browseResults[2].references, add_method.bind(null, obj), callback);
            },
 
            // now set typeDefinition
            function (callback) {
                add_typeDefinition.bind(null, obj)(browseResults[3].references, callback);
            },
 
            //
            function (callback) { // FromState
                // fromState
                const reference = browseResults[4].references ? browseResults[4].references[0] : null;
                // fromState
                if (reference) {
                    return addFromState(obj, reference, callback);
                }
                callback();
            },
            function (callback) { // ToState
                const reference = browseResults[5].references ? browseResults[5].references[0] : null;
                // fromState
                if (reference) {
                    return addToState(obj, reference, callback);
                }
                callback();
            },
            function (callback) { // Organizes
                async.map(browseResults[6].references, addFolderElement.bind(null, obj), callback);
            }
 
        ], callback);
 
    });
}
 
/**
 * @method getObject
 *
 * @param proxyManager
 * @param nodeId
 * @param options
 * @param callback {Function}
 * @param callback.err
 * @param callback.clientObject
 *
 */
function getObject(proxyManager, nodeId, options, callback) {
 
    const session = proxyManager.session;
 
    nodeId = coerceNodeId(nodeId);
 
    if (nodeId.isEmpty()) {
        return setImmediate(function() {
            callback(new Error(" Invalid empty node in getObject"));
        });
    }
 
    const nodesToRead = [
        {
            nodeId: nodeId,
            attributeId: AttributeIds.BrowseName
        },
        {
            nodeId: nodeId,
            attributeId: AttributeIds.Description
        },
        {
            nodeId: nodeId,
            attributeId: AttributeIds.NodeClass
        }
    ];
 
    function read_accessLevels(clientObject, callback) {
        const nodesToRead = [
            {
                nodeId: nodeId,
                attributeId: AttributeIds.Value
            },
            {
                nodeId: nodeId,
                attributeId: AttributeIds.UserAccessLevel
            },
            {
                nodeId: nodeId,
                attributeId: AttributeIds.AccessLevel
            }
        ];
        session.read(nodesToRead, 1, function (err, dataValues) {
            if (dataValues[0].statusCode === StatusCodes.Good) {
                clientObject.dataValue = AccessLevelFlag.get(dataValues[0].value);
            }
            if (dataValues[1].statusCode === StatusCodes.Good) {
                //xx console.log("AccessLevel ", results[3].value.toString())
                clientObject.userAccessLevel = AccessLevelFlag.get(dataValues[1].value.value);
            }
            if (dataValues[2].statusCode === StatusCodes.Good) {
                clientObject.accessLevel = AccessLevelFlag.get(dataValues[2].value.value);
            }
            callback(err);
        });
    }
 
    let clientObject;
 
    async.series([
 
        function (callback) {
            // readAttributes like browseName and references
            session.read(nodesToRead, 1, function (err, dataValues) {
 
                if (!err) {
 
                    if (dataValues[0].statusCode === StatusCodes.BadNodeIdUnknown) {
                        //xx console.log(" INVALID NODE ", nodeId.toString());
                        return callback(new Error("Invalid Node " + nodeId.toString()));
                    }
 
                    clientObject = new ProxyObject(proxyManager, nodeId);
 
                    ///x console.log("xxxx ,s",results.map(function(a){ return a.toString();}));
 
                    clientObject.browseName = dataValues[0].value.value;
                    clientObject.description = (dataValues[1].value ? dataValues[1].value.value : "");
                    clientObject.nodeClass = NodeClass.get(dataValues[2].value.value);
                    //xx console.log("xxx nodeClass = ",clientObject.nodeClass.toString());
 
                    if (clientObject.nodeClass === NodeClass.Variable) {
                        return read_accessLevels(clientObject, callback);
                    }
                }
                callback(err);
            });
        },
        function (callback) {
 
            // install monitored item
            if (clientObject.nodeClass === NodeClass.Variable) {
                //xx console.log("xxxx -> ???", clientObject.nodeId.toString(), clientObject.nodeClass.toString());
                return proxyManager._monitor_value(clientObject, callback);
            }
            callback();
        },
 
 
        function (callback) {
 
            readUAStructure(proxyManager, clientObject, callback);
        }
 
        //
    ], function (err) {
 
        // istanbul ignore next
        if (err) {
            return callback(err);
        }
 
        callback(null, clientObject);
    });
}
 
 
/**
 * @class UAProxyManager
 * @param session
 * @constructor
 */
function UAProxyManager(session) {
 
    const self = this;
    self.session = session;
    assert(session instanceof ClientSession);
    self._map = {};
    // create a subscription
 
}
 
 
/**
 * @class ClientSession
 * @method createSubscription2
 * @param createSubscriptionRequest
 * @param callback
 * @param callback.err
 * @param callback.subscription
 *
 *
 * subscription.on("error',    function(err){ ... });
 * subscription.on("terminate',function(err){ ... });
 * var monitoredItem = subscription.monitor(itemToMonitor,monitoringParameters,requestedParameters,callback);
 * monitoredItem.on("changed",function( dataValue) {...});
 *
 */
ClientSession.prototype.createSubscription2 = function (createSubscriptionRequest, callback) {
    assert(_.isFunction(callback));
    const self = this;
 
    const subscription = new ClientSubscription(self, createSubscriptionRequest);
    subscription.on("error", function (err) {
 
    });
    subscription.on("started", function () {
        callback(null, subscription);
    });
};
 
/**
 * @class UAProxyManager
 * @method start
 * @param callback
 * @async
 */
UAProxyManager.prototype.start = function (callback) {
    const self = this;
 
    const createSubscriptionRequest = {
        requestedPublishingInterval: 100,
        requestedLifetimeCount: 6000,
        requestedMaxKeepAliveCount: 100,
        maxNotificationsPerPublish: 1000,
        publishingEnabled: true,
        priority: 10
    };
 
    self.session.createSubscription2(createSubscriptionRequest, function (err, subscription) {
        self.subscription = subscription;
        self.subscription.on("terminated", function () {
            self.subscription = null;
        });
        callback(err);
    });
};
 
/**
 * @method stop
 * @param callback
 * @async
 */
UAProxyManager.prototype.stop = function (callback) {
    const self = this;
    if (self.subscription) {
        self.subscription.terminate(function() {
            self.subscription = null;
            callback();
        });
 
    } else {
        callback(new Error("UAProxyManager already stopped ?"))
    }
};
 
/**
 * @method getObject
 * @param nodeId
 * @param callback
 * @async
 */
UAProxyManager.prototype.getObject = function (nodeId, callback) {
 
    let options = {};
    const self = this;
 
    setImmediate(function () {
        options = options || {};
        options.depth = options.depth || 1;
 
        const key = nodeId.toString();
 
        if (self._map.hasOwnProperty(key)) {
            return callback(null, self._map[key]);
        }
 
        getObject(self, nodeId, options, function (err, obj) {
 
            if (!err) {
                self._map[key] = obj;
            }
            callback(err, obj);
        });
    });
};
 
 
UAProxyManager.prototype._monitor_value = function (proxyObject, callback) {
 
    assert(_.isFunction(callback));
    //xx if (proxyObject.nodeId.toString() !== "ns=0;i=2257") { return;}
 
    const self = this;
 
    if (!self.subscription) {
        // some server do not provide subscription support, do not treat this as an error.
        return callback(null); // new Error("No subscription"));
    }
 
    const itemToMonitor = { // ReadValueId
        nodeId: proxyObject.nodeId,
        attributeId: AttributeIds.Value
    };
    const monitoringParameters = { // MonitoringParameters
        samplingInterval: 0, /* event-based */
        discardOldest: true,
        queueSize: 10
    };
    const requestedParameters = read_service.TimestampsToReturn.Both;
 
    const monitoredItem = self.subscription.monitor(itemToMonitor, monitoringParameters, requestedParameters, callback);
 
    // console.log("xxxxxx installing monitored Item",monitoredItem.itemToMonitor.nodeId.toString(),monitoredItem.itemToMonitor.attributeId);
    //xx proxyObject.monitoredItem = monitoredItem;
    Object.defineProperty(proxyObject, "__monitoredItem", {value: monitoredItem, enumerable: false});
 
    proxyObject.__monitoredItem.on("changed", function (dataValue) {
        proxyObject.dataValue = dataValue;
        proxyObject.emit("value_changed", dataValue);
        //xx console.log("xxx Value Changed ".red,proxyObject.nodeId.toString() , proxyObject.browseName,proxyObject.dataValue.toString());
    });
 
};
 
UAProxyManager.prototype._monitor_execution_flag = function (proxyObject, callback) {
 
    // note : proxyObject must wrap a method
    assert(_.isFunction(callback));
    assert(proxyObject.nodeId instanceof NodeId);
 
    const self = this;
 
    if (!self.subscription) {
        // some server do not provide subscription support, do not treat this as an error.
        return callback(null); // new Error("No subscription"));
    }
 
    const itemToMonitor = { // ReadValueId
        nodeId: proxyObject.nodeId,
        attributeId: AttributeIds.Executable
    };
 
    const monitoringParameters = { // MonitoringParameters
        samplingInterval: 0, /* event-based */
        discardOldest: true,
        queueSize: 10
    };
    const requestedParameters = read_service.TimestampsToReturn.None;
 
    const monitoredItem = self.subscription.monitor(itemToMonitor, monitoringParameters, requestedParameters, callback);
 
    Object.defineProperty(proxyObject, "__monitoredItem_execution_flag", {value: monitoredItem, enumerable: false});
 
    proxyObject.__monitoredItem_execution_flag.on("changed", function (dataValue) {
        proxyObject.executableFlag = dataValue.value.value;
        //xx console.log(" execution flag = ", proxyObject.executableFlag , proxyObject.browseName , proxyObject.nodeId.toString());
        //xx proxyObject.emit("execution_flag_changed",proxyObject.executableFlag);
    });
};
 
exports.UAProxyManager = UAProxyManager;
 
const thenify = require("thenify");
UAProxyManager.prototype.start = thenify.withCallback(UAProxyManager.prototype.start);
UAProxyManager.prototype.stop = thenify.withCallback(UAProxyManager.prototype.stop);
 
UAProxyManager.prototype.getObject = thenify.withCallback(UAProxyManager.prototype.getObject);
ProxyBaseNode.prototype.readValue  = thenify.withCallback(ProxyBaseNode.prototype.readValue);
ProxyBaseNode.prototype.writeValue = thenify.withCallback(ProxyBaseNode.prototype.writeValue);
The NodeOPCUA API

APIs

packages\node-opcua-client-proxy\src\proxy.js File
