@iobroker/socket-classes 0.1.7 → 0.1.8

package/README.md

@@ -69,6 +69,9 @@ io.close();
 -->
 
 ## Changelog
+### 0.1.8 (2022-05-07)
+* (bluefox) Corrected readLogs command and implement file subscriptions
+
 ### 0.1.7 (2022-05-05)
 * (bluefox) Caught some sentry errors
 

package/lib/socketAdmin.js

@@ -142,29 +142,30 @@ class SocketAdmin extends SocketCommon {
 
         if (this.server && this.server.sockets) {
             this.server.sockets.connected.forEach(socket =>
-                this.__updateSession(socket));
+                this.commands.publish(socket, 'stateChange', id, state));
+        }
+    }
 
-            this.server.sockets.emit('stateChange', id, state);
+    fileChange(id, fileName, size) {
+        if (this.server && this.server.sockets) {
+            this.server.sockets.connected.forEach(socket =>
+                this.commands.publishFile(socket, id, fileName, size));
         }
     }
 
     repoUpdated() {
         if (this.server && this.server.sockets) {
+            this.server.sockets.connected.forEach(socket =>
+                this.__updateSession(socket));
+
             this.server.sockets.emit('repoUpdated');
         }
     }
 
     objectChange(id, obj) {
         if (this.server && this.server.sockets) {
-            const clients = this.server.sockets.connected;
-
-            for (const i in clients) {
-                if (clients.hasOwnProperty(i)) {
-                    this.__updateSession(clients[i]);
-                }
-            }
-
-            this.server.sockets.emit('objectChange', id, obj);
+            this.server.sockets.connected.forEach(socket =>
+                this.commands.publish(socket, 'objectChange', id, obj));
         }
     }
 
@@ -172,8 +173,15 @@ class SocketAdmin extends SocketCommon {
         this.commands.subscribe(null, type, pattern);
     }
 
+    subscribeFile(id, pattern) {
+        this.commands.subscribe(null, 'fileChange', id, pattern);
+    }
+
     sendCommand(obj) {
-        if (this.commands.sendCommand(obj) && this.server) {
+        if (this.commands.sendCommand(obj) && this.server && this.server.sockets) {
+            this.server.sockets.connected.forEach(socket =>
+                this.__updateSession(socket));
+
             this.server.sockets.emit(obj.command, obj.message.id, obj.message.data);
         }
     }

package/lib/socketCommands.js

@@ -66,6 +66,8 @@ class SocketCommands {
         mkdir:              {type: 'file',      operation: 'write'},
         chmodFile:          {type: 'file',      operation: 'write'},
         chownFile:          {type: 'file',      operation: 'write'},
+        subscribeFiles:     {type: 'file',      operation: 'read'},
+        unsubscribeFiles:   {type: 'file',      operation: 'read'},
 
         authEnabled:        {type: '',          operation: ''},
         disconnect:         {type: '',          operation: ''},
@@ -209,24 +211,8 @@ class SocketCommands {
         }
     }
 
-    _subscribeStates(socket, pattern, callback) {
-        if (this._checkPermissions(socket, 'subscribe', callback, pattern)) {
-            if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
-                for (let p = 0; p < pattern.length; p++) {
-                    this.subscribe(socket, 'stateChange', pattern[p]);
-                }
-            } else {
-                this.subscribe(socket, 'stateChange', pattern);
-            }
-
-            this.adapter.log.level === 'debug' && this._showSubscribes(socket, 'stateChange');
-
-            typeof callback === 'function' && setImmediate(callback, null);
-        }
-    }
-
     publish(socket, type, id, obj) {
-        if (socket && socket.subscribe && socket.subscribe[type]) {
+        if (socket && socket.subscribe && socket.subscribe[type] && this._updateSession(socket)) {
             return !!socket.subscribe[type].find(sub => {
                 if (sub.regex.test(id)) {
                     socket.emit(type, id, obj);
@@ -234,15 +220,51 @@ class SocketCommands {
                 }
             });
         }
+
         return false;
     }
 
-    subscribe(socket, type, pattern) {
+    publishFile(socket, id, fileName, size) {
+        if (socket && socket.subscribe && socket.subscribe.fileChange && this._updateSession(socket)) {
+            const key = id + '####' + fileName;
+            return !!socket.subscribe.fileChange.find(sub => {
+                if (sub.regex.test(key)) {
+                    socket.emit('fileChange', id, fileName, size);
+                    return true;
+                }
+            });
+        }
+
+        return false;
+    }
+
+    _showSubscribes(socket, type) {
+        if (socket && socket.subscribe) {
+            const s = socket.subscribe[type] || [];
+            const ids = [];
+            for (let i = 0; i < s.length; i++) {
+                ids.push(s[i].pattern);
+            }
+            this.adapter.log.debug('Subscribes: ' + ids.join(', '));
+        } else {
+            this.adapter.log.debug('Subscribes: no subscribes');
+        }
+    }
+
+    subscribe(socket, type, pattern, patternFile) {
         this.subscribes[type] = this.subscribes[type] || {};
 
+        let p;
+        let key;
         pattern = pattern.toString();
+        if (patternFile && type === 'fileChange') {
+            patternFile = patternFile.toString();
+            key = pattern + '####' + patternFile;
+        } else {
+            key = pattern;
+        }
 
-        const p = pattern2RegEx(pattern);
+        p = pattern2RegEx(key);
         if (p === null) {
             return this.adapter.log.warn('Empty pattern on subscribe!');
         }
@@ -252,44 +274,42 @@ class SocketCommands {
             socket.subscribe = socket.subscribe || {};
             s = socket.subscribe[type] = socket.subscribe[type] || [];
 
-            if (s.find(item => item.pattern === pattern)) {
+            if (s.find(item => item.pattern === key)) {
                 return;
             }
-            s.push({pattern, regex: new RegExp(p)});
+            s.push({pattern: key, regex: new RegExp(p)});
         }
 
-        if (this.subscribes[type][pattern] === undefined) {
-            this.subscribes[type][pattern] = 1;
+        if (this.subscribes[type][key] === undefined) {
+            this.subscribes[type][key] = 1;
             if (type === 'stateChange') {
                 this.adapter.subscribeForeignStates(pattern);
             } else if (type === 'objectChange') {
                 this.adapter.subscribeForeignObjects && this.adapter.subscribeForeignObjects(pattern);
             } else if (type === 'log') {
                 this.adapter.requireLog && this.adapter.requireLog(true);
+            } else if (type === 'fileChange') {
+                this.adapter.subscribeForeignFiles && this.adapter.subscribeForeignFiles(pattern, patternFile);
             }
         } else {
-            this.subscribes[type][pattern]++;
+            this.subscribes[type][key]++;
         }
     };
 
-    _showSubscribes(socket, type) {
-        if (socket && socket.subscribe) {
-            const s = socket.subscribe[type] || [];
-            const ids = [];
-            for (let i = 0; i < s.length; i++) {
-                ids.push(s[i].pattern);
-            }
-            this.adapter.log.debug('Subscribes: ' + ids.join(', '));
-        } else {
-            this.adapter.log.debug('Subscribes: no subscribes');
-        }
-    }
-
-    unsubscribe(socket, type, pattern) {
+    unsubscribe(socket, type, pattern, patternFile) {
         //console.log((socket._name || socket.id) + ' unsubscribe ' + pattern);
-        this.subscribes[type] = this.subscribes[type] || {};
+        if (!this.subscribes[type]) {
+            return;
+        }
 
+        let key;
         pattern = pattern.toString();
+        if (patternFile && type === 'fileChange') {
+            patternFile = patternFile.toString();
+            key = pattern + '####' + patternFile;
+        } else {
+            key = pattern;
+        }
 
         if (socket && typeof socket === 'object') {
             if (!socket.subscribe || !socket.subscribe[type]) {
@@ -297,12 +317,12 @@ class SocketCommands {
             }
 
             for (let i = socket.subscribe[type].length - 1; i >= 0; i--) {
-                if (socket.subscribe[type][i].pattern === pattern) {
+                if (socket.subscribe[type][i].pattern === key) {
 
                     // Remove pattern from global list
-                    if (this.subscribes[type][pattern] !== undefined) {
-                        this.subscribes[type][pattern]--;
-                        if (this.subscribes[type][pattern] <= 0) {
+                    if (this.subscribes[type][key] !== undefined) {
+                        this.subscribes[type][key]--;
+                        if (this.subscribes[type][key] <= 0) {
                             if (type === 'stateChange') {
                                 //console.log((socket._name || socket.id) + ' unsubscribeForeignStates ' + pattern);
                                 this.adapter.unsubscribeForeignStates(pattern);
@@ -312,6 +332,9 @@ class SocketCommands {
                             } else if (type === 'log') {
                                 //console.log((socket._name || socket.id) + ' requireLog false');
                                 this.adapter.requireLog && this.adapter.requireLog(false);
+                            } else if (type === 'fileChange') {
+                                //console.log((socket._name || socket.id) + ' requireLog false');
+                                this.adapter.unsubscribeForeignFiles && this.adapter.unsubscribeForeignFiles(pattern, patternFile);
                             }
                             delete this.subscribes[type][pattern];
                         }
@@ -322,26 +345,25 @@ class SocketCommands {
                     return;
                 }
             }
-        } else if (pattern) {
+        } else if (key) {
             // Remove pattern from global list
-            if (this.subscribes[type][pattern] !== undefined) {
-                this.subscribes[type][pattern]--;
-                if (this.subscribes[type][pattern] <= 0) {
+            if (this.subscribes[type][key] !== undefined) {
+                this.subscribes[type][key]--;
+                if (this.subscribes[type][key] <= 0) {
                     if (type === 'stateChange') {
                         this.adapter.unsubscribeForeignStates(pattern);
                     } else if (type === 'objectChange') {
                         this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
                     } else if (type === 'log') {
                         this.adapter.requireLog && this.adapter.requireLog(false);
+                    } else if (type === 'fileChange') {
+                        this.adapter.unsubscribeForeignFiles && this.adapter.unsubscribeForeignFiles(pattern, patternFile);
                     }
-                    delete this.subscribes[type][pattern];
+                    delete this.subscribes[type][key];
                 }
             }
         } else {
-            for (pattern in this.subscribes[type]) {
-                if (!Object.prototype.hasOwnProperty.call(this.subscribes[type], pattern)) {
-                    continue;
-                }
+            Object.keys(this.subscribes[type]).forEach(pattern => {
                 if (type === 'stateChange') {
                     //console.log((socket._name || socket.id) + ' unsubscribeForeignStates ' + pattern);
                     this.adapter.unsubscribeForeignStates(pattern);
@@ -351,20 +373,24 @@ class SocketCommands {
                 } else if (type === 'log') {
                     //console.log((socket._name || socket.id) + ' requireLog false');
                     this.adapter.requireLog && this.adapter.requireLog(false);
+                } else if (type === 'fileChange') {
+                    const [id, fileName] = pattern.split('####');
+                    this.adapter.unsubscribeForeignFiles && this.adapter.unsubscribeForeignFiles(id, fileName);
                 }
-                delete this.subscribes[type][pattern];
-            }
+            });
+
+            this.subscribes[type] = {}
         }
     };
 
-    unsubscribeSocket(socket, type) {
+    subscribeSocket(socket, type) {
         if (!socket || !socket.subscribe) {
             return;
         }
 
         if (!type) {
             // all
-            return Object.keys(socket.subscribe).forEach(type => this.unsubscribeSocket(socket, type));
+            return Object.keys(socket.subscribe).forEach(type => this.subscribeSocket(socket, type));
         }
 
         if (!socket.subscribe[type]) {
@@ -373,30 +399,29 @@ class SocketCommands {
 
         for (let i = 0; i < socket.subscribe[type].length; i++) {
             const pattern = socket.subscribe[type][i].pattern;
-            if (this.subscribes[type][pattern] !== undefined) {
-                this.subscribes[type][pattern]--;
-                if (this.subscribes[type][pattern] <= 0) {
-                    if (type === 'stateChange') {
-                        this.adapter.unsubscribeForeignStates(pattern);
-                    } else if (type === 'objectChange') {
-                        this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
-                    } else if (type === 'log') {
-                        this.adapter.requireLog && this.adapter.requireLog(false);
-                    }
-                    delete this.subscribes[type][pattern];
+            if (this.subscribes[type][pattern] === undefined) {
+                this.subscribes[type][pattern] = 1;
+                if (type === 'stateChange') {
+                    this.adapter.subscribeForeignStates(pattern);
+                } else if (type === 'objectChange') {
+                    this.adapter.subscribeForeignObjects && this.adapter.subscribeForeignObjects(pattern);
+                } else if (type === 'log') {
+                    this.adapter.requireLog && this.adapter.requireLog(true);
                 }
+            } else {
+                this.subscribes[type][pattern]++;
             }
         }
     }
 
-    subscribeSocket(socket, type) {
+    unsubscribeSocket(socket, type) {
         if (!socket || !socket.subscribe) {
             return;
         }
 
         if (!type) {
             // all
-            return Object.keys(socket.subscribe).forEach(type => this.subscribeSocket(socket, type));
+            return Object.keys(socket.subscribe).forEach(type => this.unsubscribeSocket(socket, type));
         }
 
         if (!socket.subscribe[type]) {
@@ -405,18 +430,35 @@ class SocketCommands {
 
         for (let i = 0; i < socket.subscribe[type].length; i++) {
             const pattern = socket.subscribe[type][i].pattern;
-            if (this.subscribes[type][pattern] === undefined) {
-                this.subscribes[type][pattern] = 1;
-                if (type === 'stateChange') {
-                    this.adapter.subscribeForeignStates(pattern);
-                } else if (type === 'objectChange') {
-                    this.adapter.subscribeForeignObjects && this.adapter.subscribeForeignObjects(pattern);
-                } else if (type === 'log') {
-                    this.adapter.requireLog && this.adapter.requireLog(true);
+            if (this.subscribes[type][pattern] !== undefined) {
+                this.subscribes[type][pattern]--;
+                if (this.subscribes[type][pattern] <= 0) {
+                    if (type === 'stateChange') {
+                        this.adapter.unsubscribeForeignStates(pattern);
+                    } else if (type === 'objectChange') {
+                        this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
+                    } else if (type === 'log') {
+                        this.adapter.requireLog && this.adapter.requireLog(false);
+                    }
+                    delete this.subscribes[type][pattern];
+                }
+            }
+        }
+    }
+
+    _subscribeStates(socket, pattern, callback) {
+        if (this._checkPermissions(socket, 'subscribe', callback, pattern)) {
+            if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+                for (let p = 0; p < pattern.length; p++) {
+                    this.subscribe(socket, 'stateChange', pattern[p]);
                 }
             } else {
-                this.subscribes[type][pattern]++;
+                this.subscribe(socket, 'stateChange', pattern);
             }
+
+            this.adapter.log.level === 'debug' && this._showSubscribes(socket, 'stateChange');
+
+            typeof callback === 'function' && setImmediate(callback, null);
         }
     }
 
@@ -436,6 +478,38 @@ class SocketCommands {
         }
     }
 
+    _subscribeFiles(socket, id, pattern, callback) {
+        if (this._checkPermissions(socket, 'subscribeFiles', callback, pattern)) {
+            if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+                for (let p = 0; p < pattern.length; p++) {
+                    this.subscribe(socket, 'fileChange', id, pattern[p]);
+                }
+            } else {
+                this.subscribe(socket, 'fileChange', id, pattern);
+            }
+
+            this.adapter.log.level === 'debug' && this._showSubscribes(socket, 'fileChange');
+
+            typeof callback === 'function' && setImmediate(callback, null);
+        }
+    }
+
+    _unsubscribeFiles(socket, id, pattern, callback) {
+        if (this._checkPermissions(socket, 'unsubscribeFiles', callback, pattern)) {
+            if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
+                for (let p = 0; p < pattern.length; p++) {
+                    this.unsubscribe(socket, 'fileChange', id, pattern[p]);
+                }
+            } else {
+                this.unsubscribe(socket, 'fileChange', pattern);
+            }
+
+            this.adapter.log.level === 'debug' && this._showSubscribes(socket, 'fileChange');
+
+            typeof callback === 'function' && setImmediate(callback, null);
+        }
+    }
+
     addCommandHandler(command, handler) {
         if (handler) {
             this.commands[command] = handler;
@@ -765,6 +839,10 @@ class SocketCommands {
                     SocketCommands._fixCallback(callback, err, ...args));
             }
         };
+
+        this.commands['subscribeFiles'] = (socket, id, pattern, callback) => this._subscribeFiles(socket, id, pattern, callback);
+
+        this.commands['unsubscribeFiles'] = (socket, id, pattern, callback) => this._unsubscribeFiles(socket, id, pattern, callback);
     }
 
     __initCommandsStates() {

package/lib/socketCommandsAdmin.js

@@ -1,5 +1,6 @@
 const SocketCommands = require('./socketCommands');
 const axios = require('axios');
+const path = require('path');
 
 class SocketCommandsAdmin extends SocketCommands {
     static ALLOW_CACHE = [
@@ -658,7 +659,7 @@ class SocketCommandsAdmin extends SocketCommands {
                                                         const stat = fs.lstatSync(fileName + '/' + files[f]);
                                                         if (!stat.isDirectory()) {
                                                             result.list.push({
-                                                                fileName: 'log/' + transport + '/' + files[f],
+                                                                fileName: `log/${transport}/${files[f]}`,
                                                                 size: stat.size
                                                             });
                                                         }

package/lib/socketCommon.js

@@ -349,6 +349,10 @@ class SocketCommon {
         return this.commands.publish(socket, type, id, obj);
     }
 
+    publishFile(socket, id, fileName, size) {
+        return this.commands.publishFile(socket, id, fileName, size);
+    }
+
     close() {
         this._unsubscribeAll();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iobroker/socket-classes",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "ioBroker server-side web sockets",
   "author": {
     "name": "bluefox",