node-opcua-server 2.53.0 → 2.56.1

package/dist/opcua_server.js

@@ -61,6 +61,8 @@ function isSubscriptionIdInvalid(subscriptionId) {
     return subscriptionId < 0 || subscriptionId >= 0xffffffff;
 }
 // tslint:disable-next-line:no-var-requires
+const thenify = require("thenify");
+// tslint:disable-next-line:no-var-requires
 const package_info = require("../package.json");
 const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
 const errorLog = (0, node_opcua_debug_1.make_errorLog)(__filename);
@@ -93,7 +95,7 @@ function _adjust_session_timeout(sessionTimeout) {
 }
 function channel_has_session(channel, session) {
     if (session.channel === channel) {
-        (0, node_opcua_assert_1.assert)(channel.sessionTokens.hasOwnProperty(session.authenticationToken.toString()));
+        (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(channel.sessionTokens, session.authenticationToken.toString()));
         return true;
     }
     return false;
@@ -304,8 +306,7 @@ function build_scanning_node_function(context, addressSpace, monitoredItem, item
         // causes a  Notification  to be  generated.
         // only record value when it has changed
         return function func(oldDataValue, callback) {
-            const self = this;
-            (0, node_opcua_assert_1.assert)(self instanceof monitored_item_1.MonitoredItem);
+            (0, node_opcua_assert_1.assert)(this instanceof monitored_item_1.MonitoredItem);
             (0, node_opcua_assert_1.assert)(oldDataValue instanceof node_opcua_data_value_1.DataValue);
             (0, node_opcua_assert_1.assert)(typeof callback === "function");
             const newDataValue = node.readAttribute(null, itemToMonitor.attributeId);
@@ -387,6 +388,70 @@ function _installRegisterServerManager(self) {
         self.emit("serverUnregistered");
     });
 }
+function validate_applicationUri(channel, request) {
+    const applicationUri = request.clientDescription.applicationUri;
+    const clientCertificate = request.clientCertificate;
+    // if session is insecure there is no need to check certificate information
+    if (channel.securityMode === node_opcua_secure_channel_1.MessageSecurityMode.None) {
+        return true; // assume correct
+    }
+    if (!clientCertificate || clientCertificate.length === 0) {
+        return true; // can't check
+    }
+    const e = (0, node_opcua_crypto_1.exploreCertificate)(clientCertificate);
+    const applicationUriFromCert = e.tbsCertificate.extensions.subjectAltName.uniformResourceIdentifier[0];
+    /* istanbul ignore next */
+    if (applicationUriFromCert !== applicationUri) {
+        errorLog("BadCertificateUriInvalid!");
+        errorLog("applicationUri           = ", applicationUri);
+        errorLog("applicationUriFromCert   = ", applicationUriFromCert);
+    }
+    return applicationUriFromCert === applicationUri;
+}
+function validate_security_endpoint(server, request, channel) {
+    debugLog("validate_security_endpoint = ", request.endpointUrl);
+    let endpoints = server._get_endpoints(request.endpointUrl);
+    // endpointUrl String The network address that the Client used to access the Session Endpoint.
+    //             The HostName portion of the URL should be one of the HostNames for the application that are
+    //             specified in the Server’s ApplicationInstanceCertificate (see 7.2). The Server shall raise an
+    //             AuditUrlMismatchEventType event if the URL does not match the Server’s HostNames.
+    //             AuditUrlMismatchEventType event type is defined in Part 5.
+    //             The Server uses this information for diagnostics and to determine the set of
+    //             EndpointDescriptions to return in the response.
+    // ToDo: check endpointUrl validity and emit an AuditUrlMismatchEventType event if not
+    if (endpoints.length === 0) {
+        // we have a UrlMismatch here
+        const ua_server = server.engine.addressSpace.rootFolder.objects.server;
+        ua_server.raiseEvent("AuditUrlMismatchEventType", {
+            endpointUrl: { dataType: node_opcua_variant_1.DataType.String, value: request.endpointUrl }
+        });
+        debugLog("Cannot find endpoint  in available endpoints with endpointUri", request.endpointUrl);
+        if (OPCUAServer.requestExactEndpointUrl) {
+            return { errCode: node_opcua_status_code_1.StatusCodes.BadServiceUnsupported };
+        }
+        else {
+            endpoints = server._get_endpoints(null);
+        }
+    }
+    // ignore restricted endpoints
+    endpoints = endpoints.filter((e) => !e.restricted);
+    const endpoints_matching_security_mode = endpoints.filter((e) => {
+        return e.securityMode === channel.securityMode;
+    });
+    if (endpoints_matching_security_mode.length === 0) {
+        return { errCode: node_opcua_status_code_1.StatusCodes.BadSecurityModeRejected };
+    }
+    const endpoints_matching_security_policy = endpoints_matching_security_mode.filter((e) => {
+        return e.securityPolicyUri === channel.securityHeader.securityPolicyUri;
+    });
+    if (endpoints_matching_security_policy.length === 0) {
+        return { errCode: node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected };
+    }
+    if (endpoints_matching_security_policy.length !== 1) {
+        debugLog("endpoints_matching_security_policy= ", endpoints_matching_security_policy.length);
+    }
+    return { errCode: node_opcua_status_code_1.StatusCodes.Good, endpoint: endpoints_matching_security_policy[0] };
+}
 var RegisterServerMethod;
 (function (RegisterServerMethod) {
     RegisterServerMethod[RegisterServerMethod["HIDDEN"] = 1] = "HIDDEN";
@@ -404,6 +469,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
          * false if anonymous connection are not allowed
          */
         this.allowAnonymous = false;
+        this.allowAnonymous = false;
         options = options || {};
         this.options = options;
         /**
@@ -522,8 +588,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
      */
     get currentChannelCount() {
         // TODO : move to base
-        const self = this;
-        return self.endpoints.reduce((currentValue, endPoint) => {
+        return this.endpoints.reduce((currentValue, endPoint) => {
             return currentValue + endPoint.currentChannelCount;
         }, 0);
     }
@@ -692,13 +757,15 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         let eventTypeNode = eventType;
         if (typeof eventType === "string") {
             eventTypeNode = this.engine.addressSpace.findEventType(eventType);
-        }
-        /* istanbul ignore else */
-        if (eventTypeNode) {
-            return server.raiseEvent(eventTypeNode, options);
+            if (eventTypeNode) {
+                return server.raiseEvent(eventTypeNode, options);
+            }
+            else {
+                console.warn(" cannot find event type ", eventType);
+            }
         }
         else {
-            console.warn(" cannot find event type ", eventType);
+            return server.raiseEvent(eventTypeNode, options);
         }
     }
     /**
@@ -906,7 +973,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         (0, node_opcua_assert_1.assert)(typeof callback === "function");
         const userTokenType = getTokenType(userIdentityToken);
         const userTokenPolicy = findUserTokenByPolicy(session.getEndpointDescription(), userTokenType, userIdentityToken.policyId);
-        (0, node_opcua_assert_1.assert)(userTokenPolicy);
+        /** istanbul ignore next */
+        if (!userTokenPolicy) {
+            return callback(null, false);
+        }
         // find if a userToken exists
         if (userIdentityToken instanceof node_opcua_service_session_1.UserNameIdentityToken) {
             return this.userNameIdentityTokenAuthenticateUser(channel, session, userTokenPolicy, userIdentityToken, callback);
@@ -917,12 +987,12 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         return crypto.randomBytes(32);
     }
     // session services
+    // eslint-disable-next-line max-statements
     _on_CreateSessionRequest(message, channel) {
         return __awaiter(this, void 0, void 0, function* () {
-            const server = this;
             const request = message.request;
             (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_session_1.CreateSessionRequest);
-            function rejectConnection(statusCode) {
+            function rejectConnection(server, statusCode) {
                 server.engine.incrementSecurityRejectedSessionCount();
                 const response1 = new node_opcua_service_session_1.CreateSessionResponse({
                     responseHeader: { serviceResult: statusCode }
@@ -934,12 +1004,12 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             // A Server application should limit the number of Sessions. To protect against misbehaving Clients and denial
             // of service attacks, the Server shall close the oldest Session that is not activated before reaching the
             // maximum number of supported Sessions
-            if (server.currentSessionCount >= server.maxAllowedSessionNumber) {
-                yield _attempt_to_close_some_old_unactivated_session(server);
+            if (this.currentSessionCount >= this.maxAllowedSessionNumber) {
+                yield _attempt_to_close_some_old_unactivated_session(this);
             }
             // check if session count hasn't reach the maximum allowed sessions
-            if (server.currentSessionCount >= server.maxAllowedSessionNumber) {
-                return rejectConnection(node_opcua_status_code_1.StatusCodes.BadTooManySessions);
+            if (this.currentSessionCount >= this.maxAllowedSessionNumber) {
+                return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadTooManySessions);
             }
             // Release 1.03 OPC Unified Architecture, Part 4 page 24 - CreateSession Parameters
             // client should prove a sessionName
@@ -964,86 +1034,24 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             if (!request.clientNonce || request.clientNonce.length < 32) {
                 if (channel.securityMode !== node_opcua_secure_channel_1.MessageSecurityMode.None) {
                     errorLog(chalk.red("SERVER with secure connection: Missing or invalid client Nonce "), request.clientNonce && request.clientNonce.toString("hex"));
-                    return rejectConnection(node_opcua_status_code_1.StatusCodes.BadNonceInvalid);
+                    return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadNonceInvalid);
                 }
             }
             if ((0, node_opcua_secure_channel_1.nonceAlreadyBeenUsed)(request.clientNonce)) {
                 errorLog(chalk.red("SERVER with secure connection: None has already been used"), request.clientNonce && request.clientNonce.toString("hex"));
-                return rejectConnection(node_opcua_status_code_1.StatusCodes.BadNonceInvalid);
-            }
-            function validate_applicationUri(applicationUri, clientCertificate) {
-                // if session is insecure there is no need to check certificate information
-                if (channel.securityMode === node_opcua_secure_channel_1.MessageSecurityMode.None) {
-                    return true; // assume correct
-                }
-                if (!clientCertificate || clientCertificate.length === 0) {
-                    return true; // can't check
-                }
-                const e = (0, node_opcua_crypto_1.exploreCertificate)(clientCertificate);
-                const applicationUriFromCert = e.tbsCertificate.extensions.subjectAltName.uniformResourceIdentifier[0];
-                /* istanbul ignore next */
-                if (applicationUriFromCert !== applicationUri) {
-                    errorLog("BadCertificateUriInvalid!");
-                    errorLog("applicationUri           = ", applicationUri);
-                    errorLog("applicationUriFromCert   = ", applicationUriFromCert);
-                }
-                return applicationUriFromCert === applicationUri;
+                return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadNonceInvalid);
             }
             // check application spoofing
             // check if applicationUri in createSessionRequest matches applicationUri in client Certificate
-            if (!validate_applicationUri(request.clientDescription.applicationUri, request.clientCertificate)) {
-                return rejectConnection(node_opcua_status_code_1.StatusCodes.BadCertificateUriInvalid);
-            }
-            function validate_security_endpoint(channel1) {
-                debugLog("validate_security_endpoint = ", request.endpointUrl);
-                let endpoints = server._get_endpoints(request.endpointUrl);
-                // endpointUrl String The network address that the Client used to access the Session Endpoint.
-                //             The HostName portion of the URL should be one of the HostNames for the application that are
-                //             specified in the Server’s ApplicationInstanceCertificate (see 7.2). The Server shall raise an
-                //             AuditUrlMismatchEventType event if the URL does not match the Server’s HostNames.
-                //             AuditUrlMismatchEventType event type is defined in Part 5.
-                //             The Server uses this information for diagnostics and to determine the set of
-                //             EndpointDescriptions to return in the response.
-                // ToDo: check endpointUrl validity and emit an AuditUrlMismatchEventType event if not
-                if (endpoints.length === 0) {
-                    // we have a UrlMismatch here
-                    const ua_server = server.engine.addressSpace.rootFolder.objects.server;
-                    ua_server.raiseEvent("AuditUrlMismatchEventType", {
-                        endpointUrl: { dataType: node_opcua_variant_1.DataType.String, value: request.endpointUrl }
-                    });
-                    debugLog("Cannot find endpoint  in available endpoints with endpointUri", request.endpointUrl);
-                    if (OPCUAServer.requestExactEndpointUrl) {
-                        return { errCode: node_opcua_status_code_1.StatusCodes.BadServiceUnsupported };
-                    }
-                    else {
-                        endpoints = server._get_endpoints(null);
-                    }
-                }
-                // ignore restricted endpoints
-                endpoints = endpoints.filter((e) => !e.restricted);
-                const endpoints_matching_security_mode = endpoints.filter((e) => {
-                    return e.securityMode === channel1.securityMode;
-                });
-                if (endpoints_matching_security_mode.length === 0) {
-                    return { errCode: node_opcua_status_code_1.StatusCodes.BadSecurityModeRejected };
-                }
-                const endpoints_matching_security_policy = endpoints_matching_security_mode.filter((e) => {
-                    return e.securityPolicyUri === channel1.securityHeader.securityPolicyUri;
-                });
-                if (endpoints_matching_security_policy.length === 0) {
-                    return { errCode: node_opcua_status_code_1.StatusCodes.BadSecurityPolicyRejected };
-                }
-                if (endpoints_matching_security_policy.length !== 1) {
-                    debugLog("endpoints_matching_security_policy= ", endpoints_matching_security_policy.length);
-                }
-                return { errCode: node_opcua_status_code_1.StatusCodes.Good, endpoint: endpoints_matching_security_policy[0] };
+            if (!validate_applicationUri(channel, request)) {
+                return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadCertificateUriInvalid);
             }
-            const { errCode, endpoint } = validate_security_endpoint(channel);
+            const { errCode, endpoint } = validate_security_endpoint(this, request, channel);
             if (errCode !== node_opcua_status_code_1.StatusCodes.Good) {
-                return rejectConnection(errCode);
+                return rejectConnection(this, errCode);
             }
             // see Release 1.02  27  OPC Unified Architecture, Part 4
-            const session = server.createSession({
+            const session = this.createSession({
                 clientDescription: request.clientDescription,
                 sessionTimeout: revisedSessionTimeout
             });
@@ -1065,10 +1073,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             //
             // ( this serverNonce will only be used up to the _on_ActivateSessionRequest
             //   where a new nonce will be created)
-            session.nonce = server.makeServerNonce();
+            session.nonce = this.makeServerNonce();
             session.channelId = channel.channelId;
             session._attach_channel(channel);
-            const serverCertificateChain = server.getCertificateChain();
+            const serverCertificateChain = this.getCertificateChain();
             const hasEncryption = true;
             // If the securityPolicyUri is None and none of the UserTokenPolicies requires encryption
             if (session.channel.securityMode === node_opcua_secure_channel_1.MessageSecurityMode.None) {
@@ -1102,7 +1110,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 // securityPolicyUri, userIdentityTokens, transportProfileUri and securityLevel with all
                 // other parameters set to null. Only the recommended parameters shall be verified by
                 // the client.
-                serverEndpoints: _serverEndpointsForCreateSessionResponse(server, session.endpoint.endpointUrl, request.serverUri),
+                serverEndpoints: _serverEndpointsForCreateSessionResponse(this, session.endpoint.endpointUrl, request.serverUri),
                 // This parameter is deprecated and the array shall be empty.
                 serverSoftwareCertificates: null,
                 // This is a signature generated with the private key associated with the
@@ -1111,20 +1119,20 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 // The SignatureAlgorithm shall be the AsymmetricSignatureAlgorithm specified in the
                 // SecurityPolicy for the Endpoint.
                 // The SignatureData type is defined in 7.30.
-                serverSignature: server.computeServerSignature(channel, request.clientCertificate, request.clientNonce),
+                serverSignature: this.computeServerSignature(channel, request.clientCertificate, request.clientNonce),
                 // The maximum message size accepted by the server
                 // The Client Communication Stack should return a Bad_RequestTooLarge error to the
                 // application if a request message exceeds this limit.
                 // The value zero indicates that this parameter is not used.
                 maxRequestMessageSize: 0x4000000
             });
-            server.emit("create_session", session);
+            this.emit("create_session", session);
             session.on("session_closed", (session1, deleteSubscriptions, reason) => {
                 (0, node_opcua_assert_1.assert)(typeof reason === "string");
-                if (server.isAuditing) {
+                if (this.isAuditing) {
                     (0, node_opcua_assert_1.assert)(reason === "Timeout" || reason === "Terminated" || reason === "CloseSession" || reason === "Forcing");
                     const sourceName = "Session/" + reason;
-                    server.raiseEvent("AuditSessionEventType", {
+                    this.raiseEvent("AuditSessionEventType", {
                         /* part 5 -  6.4.3 AuditEventType */
                         actionTimeStamp: { dataType: "DateTime", value: new Date() },
                         status: { dataType: "Boolean", value: true },
@@ -1139,11 +1147,11 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                         sessionId: { dataType: "NodeId", value: session1.nodeId }
                     });
                 }
-                server.emit("session_closed", session1, deleteSubscriptions);
+                this.emit("session_closed", session1, deleteSubscriptions);
             });
-            if (server.isAuditing) {
+            if (this.isAuditing) {
                 // ------------------------------------------------------------------------------------------------------
-                server.raiseEvent("AuditCreateSessionEventType", {
+                this.raiseEvent("AuditCreateSessionEventType", {
                     /* part 5 -  6.4.3 AuditEventType */
                     actionTimeStamp: { dataType: "DateTime", value: new Date() },
                     status: { dataType: "Boolean", value: true },
@@ -1168,7 +1176,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                     clientCertificate: { dataType: "ByteString", value: session.channel.clientCertificate },
                     // clientCertificateThumbprint
                     clientCertificateThumbprint: {
-                        dataType: "ByteString",
+                        dataType: "String",
                         value: thumbprint(session.channel.clientCertificate)
                     }
                 });
@@ -1196,13 +1204,12 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
      *
      */
     _on_ActivateSessionRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_session_1.ActivateSessionRequest);
         // get session from authenticationToken
         const authenticationToken = request.requestHeader.authenticationToken;
-        const session = server.getSession(authenticationToken);
-        function rejectConnection(statusCode) {
+        const session = this.getSession(authenticationToken);
+        function rejectConnection(server, statusCode) {
             if (statusCode === node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid) {
                 server.engine.incrementRejectedSessionCount();
             }
@@ -1220,7 +1227,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             // this may happen when the server has been restarted and a client tries to reconnect, thinking
             // that the previous session may still be active
             debugLog(chalk.yellow.bold(" Bad Session in  _on_ActivateSessionRequest"), authenticationToken.toString());
-            return rejectConnection(node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid);
+            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid);
         }
         // tslint:disable-next-line: no-unused-expression
         session.keepAlive ? session.keepAlive() : void 0;
@@ -1233,7 +1240,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 // it looks like session activation is being using a channel that is not the
                 // one that have been used to create the session
                 errorLog(" channel.sessionTokens === " + Object.keys(channel.sessionTokens).join(" "));
-                return rejectConnection(node_opcua_status_code_1.StatusCodes.BadSessionNotActivated);
+                return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionNotActivated);
             }
         }
         // OpcUA 1.02 part 3 $5.6.3.1 ActiveSession Set page 29
@@ -1249,55 +1256,55 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 const old_channel_cert_thumbprint = thumbprint(session.channel.clientCertificate);
                 const new_channel_cert_thumbprint = thumbprint(channel.clientCertificate);
                 if (old_channel_cert_thumbprint !== new_channel_cert_thumbprint) {
-                    return rejectConnection(node_opcua_status_code_1.StatusCodes.BadNoValidCertificates); // not sure about this code !
+                    return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadNoValidCertificates); // not sure about this code !
                 }
                 // ... In addition the Server shall verify that the  Client  supplied a  UserIdentityToken  that is
                 // identical to the token currently associated with the  Session reassign session to new channel.
                 if (!sameIdentityToken(session.userIdentityToken, request.userIdentityToken)) {
-                    return rejectConnection(node_opcua_status_code_1.StatusCodes.BadIdentityChangeNotSupported); // not sure about this code !
+                    return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadIdentityChangeNotSupported); // not sure about this code !
                 }
             }
             moveSessionToChannel(session, channel);
         }
         else if (session.status === "screwed") {
             // session has been used before being activated => this should be detected and session should be dismissed.
-            return rejectConnection(node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
         }
         else if (session.status === "closed") {
             warningLog(chalk.yellow.bold(" Bad Session Closed in  _on_ActivateSessionRequest"), authenticationToken.toString());
-            return rejectConnection(node_opcua_status_code_1.StatusCodes.BadSessionClosed);
+            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadSessionClosed);
         }
         // verify clientSignature provided by the client
-        if (!server.verifyClientSignature(session, channel, request.clientSignature)) {
-            return rejectConnection(node_opcua_status_code_1.StatusCodes.BadApplicationSignatureInvalid);
+        if (!this.verifyClientSignature(session, channel, request.clientSignature)) {
+            return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadApplicationSignatureInvalid);
         }
         // userIdentityToken may be missing , assume anonymous access then
         request.userIdentityToken = request.userIdentityToken || createAnonymousIdentityToken(session.endpoint);
         // check request.userIdentityToken is correct ( expected type and correctly formed)
-        server.isValidUserIdentityToken(channel, session, request.userIdentityToken, request.userTokenSignature, session.endpoint, (err, statusCode) => {
+        this.isValidUserIdentityToken(channel, session, request.userIdentityToken, request.userTokenSignature, session.endpoint, (err, statusCode) => {
             if (statusCode !== node_opcua_status_code_1.StatusCodes.Good) {
                 /* istanbul ignore next */
                 if (!(statusCode && statusCode instanceof node_opcua_status_code_1.StatusCode)) {
                     const a = 23;
                 }
                 (0, node_opcua_assert_1.assert)(statusCode && statusCode instanceof node_opcua_status_code_1.StatusCode, "expecting statusCode");
-                return rejectConnection(statusCode);
+                return rejectConnection(this, statusCode);
             }
             session.userIdentityToken = request.userIdentityToken;
             // check if user access is granted
-            server.isUserAuthorized(channel, session, request.userIdentityToken, (err1, authorized) => {
+            this.isUserAuthorized(channel, session, request.userIdentityToken, (err1, authorized) => {
                 /* istanbul ignore next */
                 if (err1) {
-                    return rejectConnection(node_opcua_status_code_1.StatusCodes.BadInternalError);
+                    return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadInternalError);
                 }
                 if (!authorized) {
-                    return rejectConnection(node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
+                    return rejectConnection(this, node_opcua_status_code_1.StatusCodes.BadUserAccessDenied);
                 }
                 else {
                     // extract : OPC UA part 4 - 5.6.3
                     // Once used, a serverNonce cannot be used again. For that reason, the Server returns a new
                     // serverNonce each time the ActivateSession Service is called.
-                    session.nonce = server.makeServerNonce();
+                    session.nonce = this.makeServerNonce();
                     session.status = "active";
                     response = new node_opcua_service_session_1.ActivateSessionResponse({ serverNonce: session.nonce });
                     channel.send_response("MSG", response, message);
@@ -1314,8 +1321,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                     (0, node_opcua_assert_1.assert)(session.nodeId); // sessionId
                     // xx assert(session.channel.clientCertificate instanceof Buffer);
                     (0, node_opcua_assert_1.assert)(session.sessionTimeout > 0);
-                    if (server.isAuditing) {
-                        server.raiseEvent("AuditActivateSessionEventType", {
+                    if (this.isAuditing) {
+                        this.raiseEvent("AuditActivateSessionEventType", {
                             /* part 5 -  6.4.3 AuditEventType */
                             actionTimeStamp: { dataType: "DateTime", value: new Date() },
                             status: { dataType: "Boolean", value: true },
@@ -1349,17 +1356,16 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                             secureChannelId: { dataType: "String", value: session.channel.channelId.toString() }
                         });
                     }
-                    server.emit("session_activated", session, userIdentityTokenPasswordRemoved);
+                    this.emit("session_activated", session, userIdentityTokenPasswordRemoved);
                 }
             });
         });
     }
     prepare(message, channel) {
-        const server = this;
         const request = message.request;
         // --- check that session is correct
         const authenticationToken = request.requestHeader.authenticationToken;
-        const session = server.getSession(authenticationToken, /*activeOnly*/ true);
+        const session = this.getSession(authenticationToken, /*activeOnly*/ true);
         if (!session) {
             message.session_statusCode = node_opcua_status_code_1.StatusCodes.BadSessionIdInvalid;
             return;
@@ -1386,19 +1392,19 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
      * @param ResponseClass the constructor of the response Class
      * @param message
      * @param channel
-     * @param action_to_perform
-     * @param action_to_perform.session {ServerSession}
-     * @param action_to_perform.sendResponse
-     * @param action_to_perform.sendResponse.response
-     * @param action_to_perform.sendError
-     * @param action_to_perform.sendError.statusCode
-     * @param action_to_perform.sendError.diagnostics
+     * @param actionToPerform
+     * @param actionToPerform.session {ServerSession}
+     * @param actionToPerform.sendResponse
+     * @param actionToPerform.sendResponse.response
+     * @param actionToPerform.sendError
+     * @param actionToPerform.sendError.statusCode
+     * @param actionToPerform.sendError.diagnostics
      *
      * @private
      */
-    _apply_on_SessionObject(ResponseClass, message, channel, action_to_perform) {
+    _apply_on_SessionObject(ResponseClass, message, channel, actionToPerform) {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, node_opcua_assert_1.assert)(typeof action_to_perform === "function");
+            (0, node_opcua_assert_1.assert)(typeof actionToPerform === "function");
             function sendResponse(response1) {
                 try {
                     (0, node_opcua_assert_1.assert)(response1 instanceof ResponseClass);
@@ -1461,44 +1467,28 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 message.session.keepAlive();
             }
             message.session.incrementTotalRequestCount();
-            yield action_to_perform(message.session, sendResponse, sendError);
+            yield actionToPerform(message.session, sendResponse, sendError);
         });
     }
-    /**
-     * @method _apply_on_Subscription
-     * @param ResponseClass
-     * @param message
-     * @param channel
-     * @param action_to_perform
-     * @private
-     */
-    _apply_on_Subscription(ResponseClass, message, channel, action_to_perform) {
+    _apply_on_Subscription(ResponseClass, message, channel, actionToPerform) {
         return __awaiter(this, void 0, void 0, function* () {
-            (0, node_opcua_assert_1.assert)(typeof action_to_perform === "function");
+            (0, node_opcua_assert_1.assert)(typeof actionToPerform === "function");
             const request = message.request;
-            (0, node_opcua_assert_1.assert)(request.hasOwnProperty("subscriptionId"));
+            (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(request, "subscriptionId"));
             this._apply_on_SessionObject(ResponseClass, message, channel, (session, sendResponse, sendError) => __awaiter(this, void 0, void 0, function* () {
                 const subscription = session.getSubscription(request.subscriptionId);
                 if (!subscription) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadSubscriptionIdInvalid);
                 }
                 subscription.resetLifeTimeAndKeepAliveCounters();
-                yield action_to_perform(session, subscription, sendResponse, sendError);
+                yield actionToPerform(session, subscription, sendResponse, sendError);
             }));
         });
     }
-    /**
-     * @method _apply_on_SubscriptionIds
-     * @param ResponseClass
-     * @param message
-     * @param channel
-     * @param action_to_perform
-     * @private
-     */
-    _apply_on_SubscriptionIds(ResponseClass, message, channel, action_to_perform) {
-        (0, node_opcua_assert_1.assert)(typeof action_to_perform === "function");
+    _apply_on_SubscriptionIds(ResponseClass, message, channel, actionToPerform) {
+        (0, node_opcua_assert_1.assert)(typeof actionToPerform === "function");
         const request = message.request;
-        (0, node_opcua_assert_1.assert)(request.hasOwnProperty("subscriptionIds"));
+        (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(request, "subscriptionIds"));
         this._apply_on_SessionObject(ResponseClass, message, channel, (session, sendResponse, sendError) => __awaiter(this, void 0, void 0, function* () {
             const subscriptionIds = request.subscriptionIds;
             if (!request.subscriptionIds || request.subscriptionIds.length === 0) {
@@ -1507,7 +1497,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             //  if (request.subscriptionIds.length > OPCUAServer.MAX_SUBSCRIPTION) {
             //    return sendError(StatusCodes.BadTooManyOperations);
             //  }
-            const results = subscriptionIds.map((subscriptionId) => action_to_perform(session, subscriptionId));
+            const results = subscriptionIds.map((subscriptionId) => actionToPerform(session, subscriptionId));
             // resolve potential pending promises ....
             for (let i = 0; i < results.length; i++) {
                 if (results[i].then) {
@@ -1525,15 +1515,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             sendResponse(response);
         }));
     }
-    /**
-     * @method _apply_on_Subscriptions
-     * @param ResponseClass
-     * @param message
-     * @param channel
-     * @param action_to_perform
-     * @private
-     */
-    _apply_on_Subscriptions(ResponseClass, message, channel, action_to_perform) {
+    _apply_on_Subscriptions(ResponseClass, message, channel, actionToPerform) {
         this._apply_on_SubscriptionIds(ResponseClass, message, channel, (session, subscriptionId) => __awaiter(this, void 0, void 0, function* () {
             /* istanbul ignore next */
             if (isSubscriptionIdInvalid(subscriptionId)) {
@@ -1543,13 +1525,11 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             if (!subscription) {
                 return node_opcua_status_code_1.StatusCodes.BadSubscriptionIdInvalid;
             }
-            return action_to_perform(session, subscription);
+            return actionToPerform(session, subscription);
         }));
     }
     _closeSession(authenticationToken, deleteSubscriptions, reason) {
         return __awaiter(this, void 0, void 0, function* () {
-            const server = this;
-            //
             if (deleteSubscriptions && this.options.onDeleteMonitoredItem) {
                 const session = this.getSession(authenticationToken);
                 if (session) {
@@ -1559,7 +1539,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                     }
                 }
             }
-            yield server.engine.closeSession(authenticationToken, deleteSubscriptions, reason);
+            yield this.engine.closeSession(authenticationToken, deleteSubscriptions, reason);
         });
     }
     /**
@@ -1569,7 +1549,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
      * @private
      */
     _on_CloseSessionRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_session_1.CloseSessionRequest);
         let response;
@@ -1606,7 +1585,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
      * @private
      */
     _on_BrowseRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_browse_1.BrowseRequest);
         const diagnostic = {};
@@ -1614,7 +1592,7 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             let response;
             // test view
             if (request.view && !request.view.viewId.isEmpty()) {
-                let theView = server.engine.addressSpace.findNode(request.view.viewId);
+                let theView = this.engine.addressSpace.findNode(request.view.viewId);
                 if (theView && theView.nodeClass !== node_opcua_data_model_1.NodeClass.View) {
                     // Error: theView is not a View
                     diagnostic.localizedText = { text: "Expecting a view here" };
@@ -1627,16 +1605,16 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             if (!request.nodesToBrowse || request.nodesToBrowse.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerBrowse > 0) {
-                if (request.nodesToBrowse.length > server.engine.serverCapabilities.operationLimits.maxNodesPerBrowse) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerBrowse > 0) {
+                if (request.nodesToBrowse.length > this.engine.serverCapabilities.operationLimits.maxNodesPerBrowse) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
             // limit results to requestedMaxReferencesPerNode further so it never exceed a too big number
             const requestedMaxReferencesPerNode = Math.min(9876, request.requestedMaxReferencesPerNode);
             (0, node_opcua_assert_1.assert)(request.nodesToBrowse[0].schema.name === "BrowseDescription");
-            const context = new node_opcua_address_space_1.SessionContext({ session, server });
-            const f = (0, util_1.callbackify)(server.engine.browseWithAutomaticExpansion).bind(server.engine);
+            const context = new node_opcua_address_space_1.SessionContext({ session, server: this });
+            const f = (0, util_1.callbackify)(this.engine.browseWithAutomaticExpansion).bind(this.engine);
             f(request.nodesToBrowse, context, (err, results) => {
                 // istanbul ignore next
                 if (!results) {
@@ -1644,20 +1622,25 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 }
                 (0, node_opcua_assert_1.assert)(results[0].schema.name === "BrowseResult");
                 // handle continuation point and requestedMaxReferencesPerNode
-                const maxBrowseContinuationPoints = server.engine.serverCapabilities.maxBrowseContinuationPoints;
+                const maxBrowseContinuationPoints = this.engine.serverCapabilities.maxBrowseContinuationPoints;
                 results = results.map((result) => {
                     (0, node_opcua_assert_1.assert)(!result.continuationPoint);
                     // istanbul ignore next
                     if (!session.continuationPointManager) {
                         return new node_opcua_types_1.BrowseResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadNoContinuationPoints });
                     }
-                    if (session.continuationPointManager.hasReachMaximum(maxBrowseContinuationPoints)) {
+                    if (session.continuationPointManager.hasReachedMaximum(maxBrowseContinuationPoints)) {
                         return new node_opcua_types_1.BrowseResult({ statusCode: node_opcua_status_code_1.StatusCodes.BadNoContinuationPoints });
                     }
-                    const truncatedResult = session.continuationPointManager.register(requestedMaxReferencesPerNode, result.references || []);
-                    (0, node_opcua_assert_1.assert)(truncatedResult.statusCode === node_opcua_status_code_1.StatusCodes.Good);
-                    truncatedResult.statusCode = result.statusCode;
-                    return new node_opcua_types_1.BrowseResult(truncatedResult);
+                    const truncatedResult = session.continuationPointManager.registerReferences(requestedMaxReferencesPerNode, result.references || [], { continuationPoint: null });
+                    let { statusCode } = truncatedResult;
+                    const { continuationPoint, values } = truncatedResult;
+                    statusCode = result.statusCode;
+                    return new node_opcua_types_1.BrowseResult({
+                        statusCode,
+                        continuationPoint,
+                        references: values
+                    });
                 });
                 response = new node_opcua_service_browse_1.BrowseResponse({
                     diagnosticInfos: undefined,
@@ -1677,31 +1660,21 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_browse_1.BrowseNextRequest);
         this._apply_on_SessionObject(node_opcua_service_browse_1.BrowseNextResponse, message, channel, (session, sendResponse, sendError) => {
-            let response;
             if (!request.continuationPoints || request.continuationPoints.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
-            // A Boolean parameter with the following values:
-            let results;
-            if (request.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 = request.continuationPoints.map((continuationPoint) => {
-                    return session.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 = request.continuationPoints.map((continuationPoint) => {
-                    return session.continuationPointManager.getNext(continuationPoint);
-                });
-            }
-            response = new node_opcua_service_browse_1.BrowseNextResponse({
+            const results = request.continuationPoints
+                .map((continuationPoint, index) => session.continuationPointManager.getNextReferences(0, {
+                continuationPoint,
+                index,
+                releaseContinuationPoints: request.releaseContinuationPoints
+            }))
+                .map((r) => ({
+                continuationPoint: r.continuationPoint,
+                references: r.values,
+                statusCode: r.statusCode
+            }));
+            const response = new node_opcua_service_browse_1.BrowseNextResponse({
                 diagnosticInfos: undefined,
                 results
             });
@@ -1710,11 +1683,10 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     }
     // read services
     _on_ReadRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_read_1.ReadRequest);
         this._apply_on_SessionObject(node_opcua_service_read_1.ReadResponse, message, channel, (session, sendResponse, sendError) => {
-            const context = new node_opcua_address_space_1.SessionContext({ session, server });
+            const context = new node_opcua_address_space_1.SessionContext({ session, server: this });
             let response;
             let results = [];
             const timestampsToReturn = request.timestampsToReturn;
@@ -1730,8 +1702,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             }
             (0, node_opcua_assert_1.assert)(request.nodesToRead[0].schema.name === "ReadValueId");
             // limit size of nodesToRead array to maxNodesPerRead
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerRead > 0) {
-                if (request.nodesToRead.length > server.engine.serverCapabilities.operationLimits.maxNodesPerRead) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerRead > 0) {
+                if (request.nodesToRead.length > this.engine.serverCapabilities.operationLimits.maxNodesPerRead) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -1740,9 +1712,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 nodeToRead.nodeId = session.resolveRegisteredNode(nodeToRead.nodeId);
             }
             // ask for a refresh of asynchronous variables
-            server.engine.refreshValues(request.nodesToRead, request.maxAge, (err) => {
+            this.engine.refreshValues(request.nodesToRead, request.maxAge, (err) => {
                 (0, node_opcua_assert_1.assert)(!err, " error not handled here , fix me");
-                results = server.engine.read(context, request);
+                results = this.engine.read(context, request);
                 (0, node_opcua_assert_1.assert)(results[0].schema.name === "DataValue");
                 (0, node_opcua_assert_1.assert)(results.length === request.nodesToRead.length);
                 response = new node_opcua_service_read_1.ReadResponse({
@@ -1758,7 +1730,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     }
     // read services
     _on_HistoryReadRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_history_1.HistoryReadRequest);
         this._apply_on_SessionObject(node_opcua_service_history_1.HistoryReadResponse, message, channel, (session, sendResponse, sendError) => {
@@ -1773,27 +1744,27 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             }
             (0, node_opcua_assert_1.assert)(request.nodesToRead[0].schema.name === "HistoryReadValueId");
             // limit size of nodesToRead array to maxNodesPerRead
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerRead > 0) {
-                if (request.nodesToRead.length > server.engine.serverCapabilities.operationLimits.maxNodesPerRead) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerRead > 0) {
+                if (request.nodesToRead.length > this.engine.serverCapabilities.operationLimits.maxNodesPerRead) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
             // todo : handle
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadData > 0) {
-                if (request.nodesToRead.length > server.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadData) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadData > 0) {
+                if (request.nodesToRead.length > this.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadData) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadEvents > 0) {
-                if (request.nodesToRead.length > server.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadEvents) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadEvents > 0) {
+                if (request.nodesToRead.length > this.engine.serverCapabilities.operationLimits.maxNodesPerHistoryReadEvents) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
-            const context = new node_opcua_address_space_1.SessionContext({ session, server });
+            const context = new node_opcua_address_space_1.SessionContext({ session, server: this });
             // ask for a refresh of asynchronous variables
-            server.engine.refreshValues(request.nodesToRead, 0, (err) => {
+            this.engine.refreshValues(request.nodesToRead, 0, (err) => {
                 (0, node_opcua_assert_1.assert)(!err, " error not handled here , fix me"); // TODO
-                server.engine.historyRead(context, request, (err1, results) => {
+                this.engine.historyRead(context, request, (err1, results) => {
                     if (err1) {
                         return sendError(node_opcua_status_code_1.StatusCodes.BadHistoryOperationInvalid);
                     }
@@ -1827,7 +1798,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
    // it reports an unconditional success.
    */
     _on_WriteRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_write_1.WriteRequest);
         (0, node_opcua_assert_1.assert)(!request.nodesToWrite || Array.isArray(request.nodesToWrite));
@@ -1836,8 +1806,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             if (!request.nodesToWrite || request.nodesToWrite.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerWrite > 0) {
-                if (request.nodesToWrite.length > server.engine.serverCapabilities.operationLimits.maxNodesPerWrite) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerWrite > 0) {
+                if (request.nodesToWrite.length > this.engine.serverCapabilities.operationLimits.maxNodesPerWrite) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -1845,9 +1815,9 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             for (const nodeToWrite of request.nodesToWrite) {
                 nodeToWrite.nodeId = session.resolveRegisteredNode(nodeToWrite.nodeId);
             }
-            const context = new node_opcua_address_space_1.SessionContext({ session, server });
+            const context = new node_opcua_address_space_1.SessionContext({ session, server: this });
             (0, node_opcua_assert_1.assert)(request.nodesToWrite[0].schema.name === "WriteValue");
-            server.engine.write(context, request.nodesToWrite, (err, results) => {
+            this.engine.write(context, request.nodesToWrite, (err, results) => {
                 (0, node_opcua_assert_1.assert)(!err);
                 (0, node_opcua_assert_1.assert)(Array.isArray(results));
                 (0, node_opcua_assert_1.assert)(results.length === request.nodesToWrite.length);
@@ -1861,13 +1831,12 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     }
     // subscription services
     _on_CreateSubscriptionRequest(message, channel) {
-        const server = this;
-        const engine = server.engine;
+        const engine = this.engine;
         const addressSpace = engine.addressSpace;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.CreateSubscriptionRequest);
         this._apply_on_SessionObject(node_opcua_service_subscription_1.CreateSubscriptionResponse, message, channel, (session, sendResponse, sendError) => {
-            const context = new node_opcua_address_space_1.SessionContext({ session, server });
+            const context = new node_opcua_address_space_1.SessionContext({ session, server: this });
             if (session.currentSubscriptionCount >= OPCUAServer.MAX_SUBSCRIPTION) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadTooManySubscriptions);
             }
@@ -1885,16 +1854,15 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         });
     }
     _on_DeleteSubscriptionsRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.DeleteSubscriptionsRequest);
         this._apply_on_SubscriptionIds(node_opcua_service_subscription_1.DeleteSubscriptionsResponse, message, channel, (session, subscriptionId) => __awaiter(this, void 0, void 0, function* () {
-            let subscription = server.engine.findOrphanSubscription(subscriptionId);
+            let subscription = this.engine.findOrphanSubscription(subscriptionId);
             // istanbul ignore next
             if (subscription) {
                 warningLog("Deleting an orphan subscription", subscriptionId);
                 yield this._beforeDeleteSubscription(subscription);
-                return server.engine.deleteOrphanSubscription(subscription);
+                return this.engine.deleteOrphanSubscription(subscription);
             }
             subscription = session.getSubscription(subscriptionId);
             if (subscription) {
@@ -1914,15 +1882,13 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         //              changes since the last Publish response was sent.
         //    This parameter only applies to MonitoredItems used for monitoring Attribute changes.
         //
-        const server = this;
-        const engine = server.engine;
+        const engine = this.engine;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.TransferSubscriptionsRequest);
         this._apply_on_SubscriptionIds(node_opcua_service_subscription_1.TransferSubscriptionsResponse, message, channel, (session, subscriptionId) => __awaiter(this, void 0, void 0, function* () { return yield engine.transferSubscription(session, subscriptionId, request.sendInitialValues); }));
     }
     _on_CreateMonitoredItemsRequest(message, channel) {
-        const server = this;
-        const engine = server.engine;
+        const engine = this.engine;
         const addressSpace = engine.addressSpace;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.CreateMonitoredItemsRequest);
@@ -1934,8 +1900,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             if (!request.itemsToCreate || request.itemsToCreate.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
-            if (server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
-                if (request.itemsToCreate.length > server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
+            if (this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
+                if (request.itemsToCreate.length > this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -1983,7 +1949,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         }));
     }
     _on_ModifyMonitoredItemsRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.ModifyMonitoredItemsRequest);
         this._apply_on_Subscription(node_opcua_service_subscription_1.ModifyMonitoredItemsResponse, message, channel, (session, subscription, sendResponse, sendError) => __awaiter(this, void 0, void 0, function* () {
@@ -1995,8 +1960,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
             /* istanbul ignore next */
-            if (server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
-                if (request.itemsToModify.length > server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
+            if (this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
+                if (request.itemsToModify.length > this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -2040,7 +2005,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         }));
     }
     _on_DeleteMonitoredItemsRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.DeleteMonitoredItemsRequest);
         this._apply_on_Subscription(node_opcua_service_subscription_1.DeleteMonitoredItemsResponse, message, channel, (session, subscription, sendResponse, sendError) => __awaiter(this, void 0, void 0, function* () {
@@ -2049,8 +2013,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
             /* istanbul ignore next */
-            if (server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
-                if (request.monitoredItemIds.length > server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
+            if (this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
+                if (request.monitoredItemIds.length > this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -2078,7 +2042,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         }));
     }
     _on_SetTriggeringRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.SetTriggeringRequest);
         this._apply_on_Subscription(node_opcua_service_subscription_1.SetTriggeringResponse, message, channel, (session, subscription, sendResponse, sendError) => __awaiter(this, void 0, void 0, function* () {
@@ -2092,8 +2055,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
              *
              */
             const maxElements = (linksToAdd ? linksToAdd.length : 0) + (linksToRemove ? linksToRemove.length : 0);
-            if (server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
-                if (maxElements > server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
+            if (this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
+                if (maxElements > this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -2144,7 +2107,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     // Bad_SubscriptionIdInvalid
     // Bad_MonitoringModeInvalid
     _on_SetMonitoringModeRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_subscription_1.SetMonitoringModeRequest);
         this._apply_on_Subscription(node_opcua_service_subscription_1.SetMonitoringModeResponse, message, channel, (session, subscription, sendResponse, sendError) => __awaiter(this, void 0, void 0, function* () {
@@ -2153,8 +2115,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
             /* istanbul ignore next */
-            if (server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
-                if (request.monitoredItemIds.length > server.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
+            if (this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall > 0) {
+                if (request.monitoredItemIds.length > this.engine.serverCapabilities.operationLimits.maxMonitoredItemsPerCall) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -2180,18 +2142,17 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     _on_TranslateBrowsePathsToNodeIdsRequest(message, channel) {
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_translate_browse_path_1.TranslateBrowsePathsToNodeIdsRequest);
-        const server = this;
         this._apply_on_SessionObject(node_opcua_service_translate_browse_path_1.TranslateBrowsePathsToNodeIdsResponse, message, channel, (session, sendResponse, sendError) => __awaiter(this, void 0, void 0, function* () {
             if (!request.browsePaths || request.browsePaths.length === 0) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadNothingToDo);
             }
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerTranslateBrowsePathsToNodeIds > 0) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerTranslateBrowsePathsToNodeIds > 0) {
                 if (request.browsePaths.length >
-                    server.engine.serverCapabilities.operationLimits.maxNodesPerTranslateBrowsePathsToNodeIds) {
+                    this.engine.serverCapabilities.operationLimits.maxNodesPerTranslateBrowsePathsToNodeIds) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
-            const browsePathsResults = request.browsePaths.map((browsePath) => server.engine.browsePath(browsePath));
+            const browsePathsResults = request.browsePaths.map((browsePath) => this.engine.browsePath(browsePath));
             const response = new node_opcua_service_translate_browse_path_1.TranslateBrowsePathsToNodeIdsResponse({
                 diagnosticInfos: null,
                 results: browsePathsResults
@@ -2205,7 +2166,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
     // Bad_TooManyOperations See Table 165 for the description of this result code.
     //
     _on_CallRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_call_1.CallRequest);
         this._apply_on_SessionObject(node_opcua_service_call_1.CallResponse, message, channel, (session, sendResponse, sendError) => {
@@ -2215,14 +2175,14 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
             }
             // the MaxNodesPerMethodCall Property indicates the maximum size of the methodsToCall array when
             // a Client calls the Call Service.
-            let maxNodesPerMethodCall = server.engine.serverCapabilities.operationLimits.maxNodesPerMethodCall;
+            let maxNodesPerMethodCall = this.engine.serverCapabilities.operationLimits.maxNodesPerMethodCall;
             maxNodesPerMethodCall = maxNodesPerMethodCall <= 0 ? 1000 : maxNodesPerMethodCall;
             if (request.methodsToCall.length > maxNodesPerMethodCall) {
                 return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
             }
             /* jshint validthis: true */
-            const addressSpace = server.engine.addressSpace;
-            const context = new node_opcua_address_space_1.SessionContext({ session, server });
+            const addressSpace = this.engine.addressSpace;
+            const context = new node_opcua_address_space_1.SessionContext({ session, server: this });
             async.map(request.methodsToCall, node_opcua_address_space_1.callMethodHelper.bind(null, context, addressSpace), (err, results) => {
                 /* istanbul ignore next */
                 if (err) {
@@ -2237,7 +2197,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         });
     }
     _on_RegisterNodesRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_register_node_1.RegisterNodesRequest);
         this._apply_on_SessionObject(node_opcua_service_register_node_1.RegisterNodesResponse, message, channel, (session, sendResponse, sendError) => {
@@ -2246,8 +2205,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 response = new node_opcua_service_register_node_1.RegisterNodesResponse({ responseHeader: { serviceResult: node_opcua_status_code_1.StatusCodes.BadNothingToDo } });
                 return sendResponse(response);
             }
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes > 0) {
-                if (request.nodesToRegister.length > server.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes > 0) {
+                if (request.nodesToRegister.length > this.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -2266,7 +2225,6 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
         });
     }
     _on_UnregisterNodesRequest(message, channel) {
-        const server = this;
         const request = message.request;
         (0, node_opcua_assert_1.assert)(request instanceof node_opcua_service_register_node_1.UnregisterNodesRequest);
         this._apply_on_SessionObject(node_opcua_service_register_node_1.UnregisterNodesResponse, message, channel, (session, sendResponse, sendError) => {
@@ -2276,8 +2234,8 @@ class OPCUAServer extends base_server_1.OPCUABaseServer {
                 response = new node_opcua_service_register_node_1.UnregisterNodesResponse({ responseHeader: { serviceResult: node_opcua_status_code_1.StatusCodes.BadNothingToDo } });
                 return sendResponse(response);
             }
-            if (server.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes > 0) {
-                if (request.nodesToUnregister.length > server.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes) {
+            if (this.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes > 0) {
+                if (request.nodesToUnregister.length > this.engine.serverCapabilities.operationLimits.maxNodesPerRegisterNodes) {
                     return sendError(node_opcua_status_code_1.StatusCodes.BadTooManyOperations);
                 }
             }
@@ -2398,8 +2356,6 @@ OPCUAServer.fallbackSessionName = "Client didn't provide a meaningful sessionNam
  * the maximum number of subscription that can be created per server
  */
 OPCUAServer.MAX_SUBSCRIPTION = 50;
-// tslint:disable:no-var-requires
-const thenify = require("thenify");
 const opts = { multiArgs: false };
 OPCUAServer.prototype.start = thenify.withCallback(OPCUAServer.prototype.start, opts);
 OPCUAServer.prototype.initialize = thenify.withCallback(OPCUAServer.prototype.initialize, opts);