kuzzle 2.14.10 → 2.14.14

package/.kuzzlerc.sample

@@ -356,8 +356,11 @@
     //       ("gb") or terabytes ("tb")
     //   * port:
     //       The listening port for HTTP and WebSocket
+    //   * strictSdkVersion:
+    //       Raise an error when an incompatible SDK is used.
     "maxRequestSize": "1mb",
     "port": 7512,
+    "strictSdkVersion": true,
     // [logs]
     // Configuration section for Kuzzle access logs
     //   * transports:
@@ -820,11 +823,14 @@
   },
 
   // Configuration of the Kuzzle's internal statistics module
+  //   * enabled:
+  //      Enable or disable the stats module
   //   * ttl:
   //      Time to live (in seconds) of a statistics frame
   //   * statsInterval:
   //      Time (in seconds) between statistics snapshots
   "stats": {
+    "enabled": true,
     "ttl": 3600,
     "statsInterval": 10
   },

package/lib/api/funnel.js

@@ -403,7 +403,7 @@ class Funnel {
    * @returns {Promise<Request>}
    */
   async checkRights (request) {
-    if ( !global.kuzzle.config.http.cookieAuthentication
+    if ( ! global.kuzzle.config.http.cookieAuthentication
       && request.getBoolean('cookieAuth')
     ) {
       throw kerror.get(
@@ -470,8 +470,9 @@ class Funnel {
       'core:security:user:get',
       userId);
 
+    // If we have a token, link the connection with the token,
+    // this way the connection can be notified when the token has expired.
     if (global.kuzzle.config.internal.notifiableProtocols.includes(request.context.connection.protocol)) {
-      // Link the connection with the token, this way the connection can be notified when the token has expired.
       global.kuzzle.tokenManager.link(
         request.context.token,
         request.context.connection.id);
@@ -724,9 +725,12 @@ class Funnel {
    * @throws
    */
   _checkSdkVersion (request) {
-    const
-      sdkVersion = request.input.volatile && request.input.volatile.sdkVersion,
-      sdkName = request.input.volatile && request.input.volatile.sdkName;
+    if (! global.kuzzle.config.server.strictSdkVersion) {
+      return;
+    }
+
+    const sdkVersion = request.input.volatile && request.input.volatile.sdkVersion;
+    const sdkName = request.input.volatile && request.input.volatile.sdkName;
 
     // sdkVersion property is only used by Kuzzle v1 SDKs
     if (sdkVersion) {

package/lib/cluster/node.js

@@ -107,6 +107,8 @@ function getIP ({ family = 'IPv4', interface: netInterface, ip } = {}) {
     }
   }
 
+  debug('Found interfaces %o', interfaces);
+
   interfaces = interfaces.filter(n => {
     return !n.internal
       && !isInternalIP(n.address)
@@ -114,6 +116,8 @@ function getIP ({ family = 'IPv4', interface: netInterface, ip } = {}) {
       && (!ip || mustBePrivate === isPrivateIP(n.address));
   });
 
+  debug('Filtered interfaces %o', interfaces);
+
   if (interfaces.length === 0) {
     return null;
   }
@@ -156,6 +160,7 @@ class ClusterNode {
       ip: this.config.ip,
     });
 
+    debug('Found IP address: %s with config %o', this.ip, this.config);
     assert(this.ip !== null, `[CLUSTER] No suitable IP address found with the provided configuration (family: ${family}, interface: ${this.config.interface}, ip: ${this.config.ip})`);
 
     this.nodeId = null;

package/lib/cluster/state.d.ts

@@ -1,5 +1,6 @@
 import { NormalizedFilter } from 'koncorde';
 import { JSONObject } from 'kuzzle-sdk';
+import { RoomList } from '../types';
 import Long from 'long';
 import '../types/Global';
 export declare type SerializedRoomSubscriptions = {
@@ -56,7 +57,7 @@ export default class State {
      */
     removeRealtimeRoom(roomId: string, nodeId: string): void;
     countRealtimeSubscriptions(roomId: string): number;
-    listRealtimeRooms(): RealtimeRoomsList;
+    listRealtimeRooms(): RoomList;
     addRealtimeSubscription(roomId: string, nodeId: string, messageId: Long): void;
     removeRealtimeSubscription(roomId: string, nodeId: string, messageId: Long): void;
     /**
@@ -87,16 +88,6 @@ export default class State {
      */
     loadFullState(serialized: SerializedState): void;
 }
-export declare type RealtimeRoomsList = {
-    [index: string]: {
-        [collection: string]: {
-            /**
-             * Number of subscriptions per room
-             */
-            [roomId: string]: number;
-        };
-    };
-};
 export declare type SerializedState = {
     authStrategies: JSONObject[];
     rooms: SerializedRoomState[];

package/lib/config/default.config.js

@@ -234,7 +234,8 @@ module.exports = {
         rateLimit: 0,
         realtimeNotifications: true,
       }
-    }
+    },
+    strictSdkVersion: true,
   },
 
   services: {
@@ -371,6 +372,7 @@ module.exports = {
   },
 
   stats: {
+    enabled: true,
     ttl: 3600,
     statsInterval: 10
   },

package/lib/config/index.js

@@ -214,8 +214,13 @@ function checkClusterOptions (config) {
   }
 
   assert(typeof cfg.ipv6 === 'boolean', '[CONFIG] kuzzlerc.cluster.ipv6: boolean expected');
-
+  // If config is passed with env variable, ip cannot be the value null
+  // but only blank string or the string "null"
+  if (`${cfg.ip}`.length === 0 || cfg.ip === 'null') {
+    cfg.ip = null;
+  }
   assert(!cfg.ip || ['private', 'public'].includes(cfg.ip), '[CONFIG] kuzzlerc.cluster.ip: invalid value (accepted values: public, private)');
+
   assert(!cfg.interface || typeof cfg.interface === 'string', '[CONFIG] kuzzlerc.cluster.interface: value must be either null, or a string');
 }
 

package/lib/core/auth/tokenManager.d.ts

@@ -9,6 +9,9 @@ import { Token } from '../../model/security/token';
 export declare class TokenManager {
     private tokens;
     private anonymousUserId;
+    /**
+     * Map<connectionId, ManagedToken>
+     */
     private tokensByConnection;
     private timer;
     constructor();
@@ -28,6 +31,10 @@ export declare class TokenManager {
      * @param connectionId
      */
     unlink(token: Token, connectionId: string): void;
+    /**
+     * Remove token associated with a connection.
+     */
+    removeConnection(connectionId: string): Promise<void>;
     /**
      * Called when a token expires before its time (e.g. following a
      * auth:logout action)

package/lib/core/auth/tokenManager.js

@@ -60,6 +60,9 @@ const TIMEOUT_MAX = Math.pow(2, 31) - 1;
 class TokenManager {
     constructor() {
         this.anonymousUserId = null;
+        /**
+         * Map<connectionId, ManagedToken>
+         */
         this.tokensByConnection = new Map();
         this.timer = null;
         /*
@@ -91,6 +94,10 @@ class TokenManager {
     async init() {
         const anonymous = await global.kuzzle.ask('core:security:user:anonymous:get');
         this.anonymousUserId = anonymous._id;
+        global.kuzzle.on('connection:remove', connection => {
+            this.removeConnection(connection.id)
+                .catch(err => global.kuzzle.log.info(err));
+        });
     }
     runTimer() {
         if (this.tokens.array.length > 0) {
@@ -108,8 +115,7 @@ class TokenManager {
      * @param connectionId
      */
     link(token, connectionId) {
-        // Embedded SDK does not use tokens
-        if (!token || token._id === this.anonymousUserId) {
+        if (!token || token.userId === this.anonymousUserId) {
             return;
         }
         const idx = ManagedToken.indexFor(token);
@@ -137,8 +143,7 @@ class TokenManager {
      * @param connectionId
      */
     unlink(token, connectionId) {
-        // Embedded SDK does not use tokens
-        if (!token || token._id === this.anonymousUserId) {
+        if (!token || token.userId === this.anonymousUserId) {
             return;
         }
         const idx = ManagedToken.indexFor(token);
@@ -152,6 +157,17 @@ class TokenManager {
             this.tokensByConnection.delete(connectionId);
         }
     }
+    /**
+     * Remove token associated with a connection.
+     */
+    async removeConnection(connectionId) {
+        const managedToken = this.tokensByConnection.get(connectionId);
+        // Anonymous connection does not have associated token
+        if (!managedToken) {
+            return;
+        }
+        await this.expire(managedToken);
+    }
     /**
      * Called when a token expires before its time (e.g. following a
      * auth:logout action)
@@ -161,7 +177,7 @@ class TokenManager {
      * @param token
      */
     async expire(token) {
-        if (token._id === this.anonymousUserId) {
+        if (token.userId === this.anonymousUserId) {
             return;
         }
         const idx = ManagedToken.indexFor(token);
@@ -170,7 +186,7 @@ class TokenManager {
             const managedToken = this.tokens.array[searchResult];
             for (const connectionId of managedToken.connectionIds) {
                 this.tokensByConnection.delete(connectionId);
-                await global.kuzzle.ask('core:realtime:user:remove', connectionId);
+                await global.kuzzle.ask('core:realtime:connection:remove', connectionId);
             }
             this.deleteByIndex(searchResult);
         }
@@ -202,10 +218,11 @@ class TokenManager {
         const arr = this.tokens.array;
         // API key can never expire (-1)
         if (arr.length > 0 && (arr[0].expiresAt > 0 && arr[0].expiresAt < Date.now())) {
-            const connectionIds = arr[0].connectionIds;
+            const managedToken = arr[0];
             arr.shift();
-            for (const connectionId of connectionIds) {
+            for (const connectionId of managedToken.connectionIds) {
                 await global.kuzzle.ask('core:realtime:tokenExpired:notify', connectionId);
+                this.tokensByConnection.delete(connectionId);
             }
             setImmediate(() => this.checkTokensValidity());
             return;

package/lib/core/network/router.js

@@ -82,10 +82,6 @@ class Router {
 
     this.connections.delete(connId);
 
-    global.kuzzle
-      .ask('core:realtime:user:remove', requestContext.connection.id)
-      .catch(err => global.kuzzle.log.info(err));
-
     global.kuzzle.statistics.dropConnection(requestContext);
   }
 

package/lib/core/realtime/channel.d.ts

@@ -0,0 +1,64 @@
+import { RealtimeScope, RealtimeUsers } from '../../types';
+/**
+ * A channel define how notifications should be send for a particular realtime
+ * room.
+ *
+ * Channel names are sent back to users who subscribe to realtime notification,
+ * then each notification sent to them contains the associated channel.
+ *
+ * It allows to makes two subscriptions on index + collection + filters but one
+ * for documents entering the scope and the other for documents exiting the scope
+ * for example.
+ *
+ * Channels define with more granularity if a room notification should be sent:
+ *  - is the document entering or leaving the scope
+ *  - should I notify when users join or leave the room
+ *  - should I propagate the notification to other cluster nodes
+ *
+ * @property name
+ * @property scope
+ * @property users
+ * @property cluster
+ */
+export declare class Channel {
+    /**
+     * Dummy hash function since we only need to keep the channel configuration.
+     *
+     * This is 10x faster than murmur.
+     */
+    static hash(channel: Channel): string;
+    static USERS_ALLOWED_VALUES: string[];
+    static SCOPE_ALLOWED_VALUES: string[];
+    /**
+     * Identifier of the channel.
+     *
+     * Result of roomId + hash(channel)
+     */
+    name: string;
+    /**
+     * Define if notification should be send when documents are entering or leaving
+     * the subscription scope.
+     *
+     * @default "all"
+     */
+    scope: RealtimeScope;
+    /**
+     * Define if notification should be send when users join or leave the channel.
+     *
+     * @default "none"
+     */
+    users: RealtimeUsers;
+    /**
+     * Define if the notification should be propagated on other cluster nodes or
+     * only to connection subscribing on this node.
+     *
+     * This is used by the EmbeddedSDK realtime subscription to propagate or not
+     * callback execution among other nodes.
+     */
+    cluster: boolean;
+    constructor(roomId: string, { scope, users, propagate, }?: {
+        scope?: RealtimeScope;
+        users?: RealtimeUsers;
+        propagate?: boolean;
+    });
+}

package/lib/core/realtime/channel.js

@@ -0,0 +1,109 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2020 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channel = void 0;
+const kerror_1 = __importDefault(require("../../kerror"));
+const realtimeError = kerror_1.default.wrap('core', 'realtime');
+/**
+ * A channel define how notifications should be send for a particular realtime
+ * room.
+ *
+ * Channel names are sent back to users who subscribe to realtime notification,
+ * then each notification sent to them contains the associated channel.
+ *
+ * It allows to makes two subscriptions on index + collection + filters but one
+ * for documents entering the scope and the other for documents exiting the scope
+ * for example.
+ *
+ * Channels define with more granularity if a room notification should be sent:
+ *  - is the document entering or leaving the scope
+ *  - should I notify when users join or leave the room
+ *  - should I propagate the notification to other cluster nodes
+ *
+ * @property name
+ * @property scope
+ * @property users
+ * @property cluster
+ */
+class Channel {
+    constructor(roomId, { scope = 'all', users = 'none', propagate = true, } = {}) {
+        this.scope = scope;
+        this.users = users;
+        this.cluster = propagate;
+        if (!Channel.SCOPE_ALLOWED_VALUES.includes(this.scope)) {
+            throw realtimeError.get('invalid_scope');
+        }
+        if (!Channel.USERS_ALLOWED_VALUES.includes(this.users)) {
+            throw realtimeError.get('invalid_users');
+        }
+        this.name = `${roomId}-${Channel.hash(this)}`;
+    }
+    /**
+     * Dummy hash function since we only need to keep the channel configuration.
+     *
+     * This is 10x faster than murmur.
+     */
+    static hash(channel) {
+        let str = '';
+        switch (channel.users) {
+            case 'all':
+                str += '1';
+                break;
+            case 'in':
+                str += '2';
+                break;
+            case 'out':
+                str += '3';
+                break;
+            case 'none':
+                str += '3';
+                break;
+        }
+        switch (channel.cluster) {
+            case true:
+                str += '1';
+                break;
+            case false:
+                str += '2';
+                break;
+        }
+        switch (channel.scope) {
+            case 'all':
+                str += '1';
+                break;
+            case 'in':
+                str += '2';
+                break;
+            case 'out':
+                str += '3';
+                break;
+        }
+        return str;
+    }
+}
+exports.Channel = Channel;
+Channel.USERS_ALLOWED_VALUES = ['all', 'in', 'out', 'none'];
+Channel.SCOPE_ALLOWED_VALUES = Channel.USERS_ALLOWED_VALUES;
+//# sourceMappingURL=channel.js.map

package/lib/core/realtime/connectionRooms.d.ts

@@ -0,0 +1,28 @@
+import { JSONObject } from 'kuzzle-sdk';
+/**
+ * Each connection can subscribe to many rooms with different sets of volatile
+ * data.
+ *
+ * This object is responsible to keep the association between each rooms and the
+ * associated volatile data.
+ *
+ * @property rooms
+ */
+export declare class ConnectionRooms {
+    /**
+     * List of subscribed rooms and their associated volatile data
+     *
+     * Map<roomId, volatile>
+     */
+    private rooms;
+    constructor(rooms?: Map<string, JSONObject>);
+    get roomIds(): string[];
+    get count(): number;
+    addRoom(roomId: string, volatile: JSONObject): void;
+    removeRoom(roomId: string): void;
+    hasRoom(roomId: string): boolean;
+    /**
+     * Returns the volatile data for this room subscription
+     */
+    getVolatile(roomId: string): JSONObject;
+}

package/lib/core/realtime/connectionRooms.js

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2020 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionRooms = void 0;
+/**
+ * Each connection can subscribe to many rooms with different sets of volatile
+ * data.
+ *
+ * This object is responsible to keep the association between each rooms and the
+ * associated volatile data.
+ *
+ * @property rooms
+ */
+class ConnectionRooms {
+    constructor(rooms) {
+        /**
+         * List of subscribed rooms and their associated volatile data
+         *
+         * Map<roomId, volatile>
+         */
+        this.rooms = new Map();
+        if (rooms) {
+            this.rooms = rooms;
+        }
+    }
+    get roomIds() {
+        return Array.from(this.rooms.keys());
+    }
+    get count() {
+        return this.rooms.size;
+    }
+    addRoom(roomId, volatile) {
+        this.rooms.set(roomId, volatile);
+    }
+    removeRoom(roomId) {
+        this.rooms.delete(roomId);
+    }
+    hasRoom(roomId) {
+        return this.rooms.has(roomId);
+    }
+    /**
+     * Returns the volatile data for this room subscription
+     */
+    getVolatile(roomId) {
+        return this.rooms.get(roomId);
+    }
+}
+exports.ConnectionRooms = ConnectionRooms;
+//# sourceMappingURL=connectionRooms.js.map

package/lib/core/realtime/hotelClerk.d.ts

@@ -0,0 +1,140 @@
+import { KuzzleRequest } from '../../api/request';
+import { User, RoomList } from '../../types';
+/**
+ * The HotelClerk is responsible of keeping the list of rooms and subscriptions
+ * made to those rooms.
+ *
+ * When a subscription is made to a room, the HotelClerk link the connection
+ * to a channel of this room. Each channel represents a specific configuration
+ * about which kind of notification the subscriber should receive (e.g. scope in/out)
+ *
+ * When an user is subscribing, we send him back the channel he is subscribing to.
+ *
+ * Here stop the role of the HotelClerk, then the notifier will select the channels
+ * according to the notification and notify them.
+ */
+export declare class HotelClerk {
+    private module;
+    /**
+     * Number of created rooms.
+     *
+     * Used with the "subscriptionRooms" configuration limit.
+     */
+    private roomsCount;
+    /**
+     * Current realtime rooms.
+     *
+     * This object is used by the notifier to list wich channel has to be notified
+     * when a subscription scope is matching.
+     * It's also used to notify channels when an user join/exit a room.
+     *
+     * Map<roomId, Room>
+     */
+    private rooms;
+    /**
+     * Current subscribing connections handled by the HotelClerk.
+     *
+     * Each connection can subscribe to many rooms with different volatile data.
+     *
+     * This object is used to keep track of all subscriptions made by a connection
+     * to be able to unsubscribe when a connection is removed.
+     *
+     * Map<connectionId, ConnectionRooms>
+     */
+    private subscriptions;
+    /**
+     * Shortcut to the Koncorde instance on the global object.
+     */
+    private koncorde;
+    constructor(realtimeModule: any);
+    /**
+     * Registers the ask events.
+     */
+    init(): Promise<void>;
+    /**
+     * Subscribe a connection to a realtime room.
+     *
+     * The room will be created if it does not already exists.
+     *
+     * Notify other subscribers on this room about this new subscription
+     *
+     * @throws Throws if the user has already subscribed to this room name
+     *         (just for rooms with same name, there is no error if the room
+     *         has a different name with same filter) or if there is an error
+     *         during room creation
+     */
+    subscribe(request: KuzzleRequest): Promise<{
+        channel: string;
+        roomId: string;
+    }>;
+    /**
+     * Returns the list of collections of an index with realtime rooms.
+     */
+    listCollections(index: string): string[];
+    /**
+     * Joins an existing realtime room.
+     *
+     * The room may exists on another cluster node, if it's the case, the normalized
+     * filters will be fetched from the cluster.
+     */
+    join(request: KuzzleRequest): Promise<{
+        channel: any;
+        roomId: any;
+    }>;
+    /**
+     * Return the list of index, collection, rooms and subscribing connections
+     * on all index/collection pairs that the requesting user is allowed to
+     * subscribe.
+     */
+    list(user: User): Promise<RoomList>;
+    /**
+     * Removes a connections and unsubscribe it from every subscribed rooms.
+     *
+     * Usually called when an user has been disconnected from Kuzzle.
+     */
+    removeConnection(connectionId: string, notify?: boolean): Promise<void>;
+    /**
+     * Clear all connections made to this node:
+     *   - trigger appropriate core events
+     *   - send user exit room notifications
+     */
+    clearConnections(): Promise<void>;
+    /**
+     * Register a new subscription
+     *  - save the subscription on the provided room with volatile data
+     *  - add the connection to the list of active connections of the room
+     */
+    private registerSubscription;
+    /**
+     * Create new room if needed
+     *
+     * @returns {void}
+     */
+    private createRoom;
+    /**
+     * Remove a connection from a room.
+     *
+     * Also delete the rooms if it was the last connection subscribing to it.
+     *
+     */
+    unsubscribe(connectionId: string, roomId: string, notify?: boolean): Promise<void>;
+    /**
+     * Deletes a room if no user has subscribed to it, and removes it also from the
+     * real-time engine
+     */
+    private removeRoom;
+    /**
+     * Subscribes a connection to an existing room.
+     *
+     * The subscription is made on a configuration channel who will be created
+     * on the room if it does not already exists.
+     *
+     */
+    private subscribeToRoom;
+    /**
+     * Create an empty room in the RAM cache if it doesn't exists
+     *
+     * @returns True if a new room has been created
+     */
+    private newRoom;
+}