node-opcua-server 2.51.0

package/source/history_server_capabilities.ts

@@ -0,0 +1,75 @@
+/**
+ * @module node-opcua-server
+ */
+import { assert } from "node-opcua-assert";
+
+export interface HistoryServerCapabilitiesOptions {
+    accessHistoryDataCapability?: boolean;
+    accessHistoryEventsCapability?: boolean;
+    maxReturnDataValues?: number;
+    maxReturnEventValues?: number;
+    insertDataCapability?: boolean;
+    replaceDataCapability?: boolean;
+    updateDataCapability?: boolean;
+    deleteRawCapability ?: boolean;
+    deleteAtTimeCapability?: boolean;
+    insertEventCapability?: boolean;
+    replaceEventCapability?: boolean;
+    updateEventCapability?: boolean;
+    deleteEventCapability?: boolean;
+    insertAnnotationCapability?: boolean;
+}
+/**
+ */
+export class HistoryServerCapabilities {
+
+    public accessHistoryDataCapability: boolean;
+    public accessHistoryEventsCapability: boolean;
+    public maxReturnDataValues: number;
+    public maxReturnEventValues: number;
+    public insertDataCapability: boolean;
+    public replaceDataCapability: boolean;
+    public updateDataCapability: boolean;
+    public deleteRawCapability: boolean;
+    public deleteAtTimeCapability: boolean;
+    public insertEventCapability: boolean;
+    public replaceEventCapability: boolean;
+    public updateEventCapability: boolean;
+    public deleteEventCapability: boolean;
+    public insertAnnotationCapability: boolean;
+
+    constructor(options?: HistoryServerCapabilitiesOptions) {
+        options = options || {};
+
+        function coerceBool(value: boolean | undefined , defaultValue: boolean): boolean {
+            if (undefined === value) {
+                return defaultValue;
+            }
+            assert(typeof value === "boolean");
+            return value as boolean;
+        }
+
+        function coerceUInt32(value: number| undefined, defaultValue: number): number {
+            if (undefined === value) {
+                return defaultValue;
+            }
+            assert(typeof value === "number");
+            return value;
+        }
+
+        this.accessHistoryDataCapability = coerceBool(options.accessHistoryDataCapability, false);
+        this.accessHistoryEventsCapability = coerceBool(options.accessHistoryEventsCapability, false);
+        this.maxReturnDataValues = coerceUInt32(options.maxReturnDataValues, 0);
+        this.maxReturnEventValues = coerceUInt32(options.maxReturnEventValues, 0);
+        this.insertDataCapability = coerceBool(options.insertDataCapability, false);
+        this.replaceDataCapability = coerceBool(options.replaceDataCapability, false);
+        this.updateDataCapability = coerceBool(options.updateDataCapability, false);
+        this.deleteRawCapability = coerceBool(options.deleteRawCapability, false);
+        this.deleteAtTimeCapability = coerceBool(options.deleteAtTimeCapability, false);
+        this.insertEventCapability = coerceBool(options.insertEventCapability, false);
+        this.replaceEventCapability = coerceBool(options.replaceEventCapability, false);
+        this.updateEventCapability = coerceBool(options.updateEventCapability, false);
+        this.deleteEventCapability = coerceBool(options.deleteEventCapability, false);
+        this.insertAnnotationCapability = coerceBool(options.insertAnnotationCapability, false);
+    }
+}

package/source/i_channel_data.ts

@@ -0,0 +1,17 @@
+import { 
+    AsymmetricAlgorithmSecurityHeader,
+    MessageSecurityMode,
+    SecurityPolicy
+} from "node-opcua-secure-channel";
+
+export interface IChannelData {
+    channelId: number| null;
+    clientCertificate: Buffer | null;
+    clientNonce: Buffer |null,
+    clientSecurityHeader: any;
+    securityHeader: AsymmetricAlgorithmSecurityHeader |null;
+    securityMode: MessageSecurityMode;
+    securityPolicy: SecurityPolicy;
+    timeout: number;
+    transactionsCount: number;
+}

package/source/i_register_server_manager.ts

@@ -0,0 +1,24 @@
+/**
+ * @module node-opcua-server
+ */
+import { EventEmitter } from "events";
+import { ErrorCallback } from "node-opcua-status-code";
+
+
+export interface IRegisterServerManager extends EventEmitter {
+
+    discoveryServerEndpointUrl: string;
+
+    start(callback: ErrorCallback): void;
+
+    stop(callback: ErrorCallback): void;
+
+    dispose(): void;
+
+    // tslint:disable:unified-signatures
+    on(eventName: "serverRegistrationPending", eventHandler: () => void): this;
+    on(eventName: "serverRegistered", eventHandler: () => void): this;
+    on(eventName: "serverRegistrationRenewed", eventHandler: () => void): this;
+    on(eventName: "serverUnregistered", eventHandler: () => void): this;
+
+}

package/source/i_server_side_publish_engine.ts

@@ -0,0 +1,77 @@
+import { Subscription, InternalNotification } from "./server_subscription";
+import { PublishResponseOptions, PublishResponse, StatusChangeNotification } from "node-opcua-types";
+import assert from "node-opcua-assert";
+import { Queue } from "./queue";
+
+export interface INotifMsg {
+    subscriptionId: number;
+    sequenceNumber: number;
+    notificationData: any;
+    moreNotifications: boolean;
+}
+
+export interface IServerSidePublishEngine {
+    on_close_subscription(subscription: IClosedOrTransferredSubscription): void;
+    readonly pendingPublishRequestCount: number;
+    _on_tick(): void;
+    send_keep_alive_response(subscriptionId: number, future_sequence_number: number): boolean;
+    _send_response(subscription: Subscription, options: PublishResponseOptions): void;
+}
+
+export interface IClosedOrTransferredSubscription {
+    readonly hasPendingNotifications: boolean;
+    dispose(): void;
+    readonly id: number;
+    _publish_pending_notifications(): void;
+}
+export class TransferredSubscription implements IClosedOrTransferredSubscription {
+    public id: number;
+    public publishEngine: any;
+    public _pending_notification?: StatusChangeNotification;
+    private _sequence_number_generator: any;
+    constructor(options: { id: number; generator: any; publishEngine: any }) {
+        this.id = options.id;
+        this._sequence_number_generator = options.generator;
+        this.publishEngine = options.publishEngine;
+    }
+    public get hasPendingNotifications(): boolean {
+        return !!this._pending_notification;
+    }
+    dispose(): void {
+        this._pending_notification= undefined;
+        this.publishEngine = null;
+    }
+    _publish_pending_notifications(): void {
+        assert(this._pending_notification);
+        const notificationMessage = this._pending_notification!;
+        this._pending_notification = undefined;
+        const moreNotifications = false;
+        const subscriptionId = this.id;
+
+        const response = new PublishResponse({
+            moreNotifications,
+            notificationMessage: {
+                notificationData: [notificationMessage ],
+                publishTime: new Date(),
+                sequenceNumber: 0xFFFFFFFF
+            },
+            subscriptionId
+        });
+        
+        // apply sequence number and store in sent_notifications queue
+        assert(response.notificationMessage.sequenceNumber === 0xffffffff);
+        response.notificationMessage.sequenceNumber = this._get_next_sequence_number();
+        // xxx    this._sent_notifications.push(response.notificationMessage);
+        // get available sequence number;
+        const availableSequenceNumbers = [response.notificationMessage.sequenceNumber];
+        assert(
+            !response.notificationMessage ||
+                availableSequenceNumbers[availableSequenceNumbers.length - 1] === response.notificationMessage.sequenceNumber
+        );
+        response.availableSequenceNumbers = availableSequenceNumbers;
+        this.publishEngine._send_response(this, response);
+    }
+    private _get_next_sequence_number(): number {
+        return this._sequence_number_generator ? this._sequence_number_generator.next() : 0;
+    }
+}

package/source/i_socket_data.ts

@@ -0,0 +1,11 @@
+export interface ISocketData {
+    bytesRead: number;
+    bytesWritten: number;
+    localAddress: string;
+    localPort: number;
+    remoteAddress?: string;
+    remoteFamily?: string;
+    remotePort?: number;
+    timestamp: Date;
+    reason: string;
+}

package/source/index.ts

@@ -0,0 +1,14 @@
+/**
+ * @module node-opcua-server
+ */
+export * from "./base_server";
+export * from "./server_end_point";
+export * from "./register_server_manager";
+export * from "./register_server_manager_mdns_only";
+export * from "./server_publish_engine";
+export * from "./server_subscription";
+export * from "./server_session";
+export * from "./server_capabilities";
+export * from "./server_engine";
+export * from "./opcua_server";
+export * from "./monitored_item";