node-red-contrib-knx-ultimate 8.1.1 → 8.3.0

package/nodes/locales/zh-CN/knxUltimate-config.json

@@ -19,7 +19,7 @@
             "discovering": "正在发现...",
             "interfaces_found": "个接口已发现。",
             "discovery_failed": "发现失败。",
-            "weinzierl_ack_autoenabled": "检测到 Weinzierl 接口：已自动启用 'Suppress ACK request'。你可以在「高级」选项卡中关闭它。",
+            "weinzierl_ack_autoenabled": "检测到 Weinzierl 接口：已自动启用 '抑制总线 ACK 请求'。你可以在「高级」选项卡中关闭它。",
             "address": "地址",
             "iface_auto": "自动",
             "iface_manual": "手动输入接口名称",
@@ -63,15 +63,20 @@
             "configuration": "配置",
             "advanced": "高级",
             "ets_import": "ETS 导入",
-            "utility": "工具"
+            "file_cache": "文件缓存控制"
         },
         "advanced": {
             "knx_phy_addr": "KNX 物理地址",
             "show_date_status": "在状态中显示上次更新日期和时间",
             "show_device_status": "在状态中显示设备的名称 (需要 \"监听所有组地址\" )",
             "show_datapoint_status": "在状态中显示数据类型",
-            "suppress_ack": "抑制 ACK 请求 in tunneling mode",
-            "suppress_ack_help": "上面的选项有助于旧的 KNX/IP 接口兼容性 Warning: the node may not notice the disconnection from the gateway. In this case, use the watchdog in Ethernet+KNX twisted pair mode.",
+            "suppress_ack": "抑制总线 ACK 请求",
+            "suppress_ack_help": "总线 ACK。勾选后，发送到 KNX 总线的报文（Tunnel UDP、Multicast 和 Serial FT1.2）不再要求接收设备确认。在 Tunnel UDP 且“等待隧道 ACK”为“自动”时，节点也不再等待接口的确认。仅在接口需要时启用，例如某些旧的或 Weinzierl KNX/IP 接口、eibPORT 和 Loxone。默认：不勾选。",
+            "wait_tunneling_ack": "等待隧道 ACK（Tunnel UDP）",
+            "wait_tunneling_ack_auto": "自动（仅在未抑制总线 ACK 请求时）",
+            "wait_tunneling_ack_yes": "是（重发一次，然后断开）",
+            "wait_tunneling_ack_no": "否",
+            "wait_tunneling_ack_help": "接口 ACK。使用 Tunnel UDP 时，节点等待 KNX/IP 接口确认每条报文：未被确认的报文会再发送一次，然后关闭并重新建立连接。“自动”仅在未勾选“抑制总线 ACK 请求”时等待，与以前的版本相同。“是”始终等待，“否”从不等待。eibPORT 和 Loxone 网关需要同时勾选“抑制总线 ACK 请求”并选择“是”。",
             "ignoreTelegramsWithRepeatedFlag": "抑制重复的 (R-Flag) 来自总线的电报",
             "enable_flow_bubbles": "启用 flow bubbles 插件",
             "enable_flow_bubbles_help": "在编辑器中为 KNX Device 节点显示实时状态气泡。适合调试和调试期间快速观察状态。",
@@ -129,22 +134,19 @@
             "tunnel_user_password": "隧道用户密码",
             "ga_list_label": "ETS 组地址列表"
         },
-        "utility": {
-            "gather_debug": "收集调试信息和日志以便排查",
-            "get_all_used_ga": "获取 KNX 路由过滤器使用的所有 GA",
-            "read_button": "读取",
-            "copy_ga_router": "将这些组地址复制到 KNX/IP 路由器的路由表中。",
-            "clear_persist_label": "清除该网关的持久化 GA 缓存",
-            "clear_persist_button": "清除",
-            "clear_persist_confirm": "这将删除该网关的持久化 GA 缓存文件。继续？",
-            "clear_persist_ok": "删除",
-            "clear_persist_cancel": "取消",
-            "clear_persist_done": "已删除持久化 GA 缓存。",
-            "clear_persist_fail": "无法删除持久化 GA 缓存",
-            "reveal_keyring_label": "以明文显示密钥环密码 (KNX Secure)",
-            "reveal_keyring_button": "显示",
-            "reveal_keyring_loading": "正在解码密钥环，请稍候...",
-            "reveal_keyring_fail": "无法解码密钥环。请检查密钥环文件和通用密码。"
+        "file_cache": {
+            "mode": "磁盘磨损管理",
+            "mode_freshness": "新鲜度优先",
+            "mode_balanced": "均衡",
+            "mode_disabled": "禁用写入",
+            "mode_custom": "自定义间隔",
+            "interval": "写入间隔",
+            "unit_seconds": "秒",
+            "unit_minutes": "分钟",
+            "unit_hours": "小时",
+            "unit_days": "天",
+            "disabled_tip": "已禁用磁盘写入（KNX 网关的文件缓存控制）：每次重启 Node-RED 时，所有当前 GA 值以及 KNX Ultimate 节点保存的数据都将丢失。",
+            "description": "控制 KNX Ultimate 将其文件（GA 值、Scene Controller 场景、AutoResponder 值、Logger 文件、Viewer 历史记录）写入磁盘的频率，以减少 SD 卡的磨损。仅当文件内容发生变化时才会写入。日志不受影响：请使用日志级别进行控制。<br/><b>新鲜度优先</b>：每 5 秒保存一次更改。<br/><b>均衡</b>：仅在网关连接或断开时，以及 Node-RED 停止或网关重新部署时保存更改。<br/><b>禁用写入</b>：不向磁盘写入任何内容。<br/><b>自定义间隔</b>：按所选间隔（5 秒到 30 天）保存更改，并在 Node-RED 停止或网关重新部署时保存。"
         }
     }
 }

package/nodes/locales/zh-CN/knxUltimate.html

@@ -54,6 +54,8 @@
 | 响应读报文 | 收到读报文时向流程输出（用于自定义返回值）。|
 | Multiply/Decimals/Negatives | 数值缩放、四舍五入、小数与负值处理（仅数值）。|
 
+> 💾 **当初始化连接/重新连接的时候发送读取消息**（从文件读取）所用的 GA 值何时写入磁盘由 KNX 网关的**文件缓存控制**决定。选择**禁用写入**时，这些数据仅保存在内存中，每次重启 Node-RED 都会丢失。 参见 KNX 网关的**文件缓存控制**选项卡。
+
 <br/>
 <br/>
 

package/nodes/locales/zh-CN/knxUltimateUtility.html

@@ -163,6 +163,8 @@ msg = {
 
 ## AutoResponder
 
+> 💾 已存储的值何时写入磁盘由 KNX 网关的**文件缓存控制**决定。选择**禁用写入**时，这些数据仅保存在内存中，每次重启 Node-RED 都会丢失。 参见 KNX 网关的**文件缓存控制**选项卡。
+
 此节点将响应KNX总线的读取请求。
 
 节点记录所有传输到KNX总线并将值存储在内存中的电报。
@@ -503,6 +505,8 @@ global.set("KNXContextBanana_WRITE", toSend);
 
 ## 日志记录
 
+> 💾 **发送 payload 并保存到文件**的 XML 文件何时写入磁盘由 KNX 网关的**文件缓存控制**决定。选择**禁用写入**时，这些数据仅保存在内存中，每次重启 Node-RED 都会丢失。 参见 KNX 网关的**文件缓存控制**选项卡。
+
 ### Logger（日志）
 
 Logger 节点会记录所有报文，并输出一份与 ETS Bus Monitor 兼容的 XML 文件。
@@ -762,6 +766,8 @@ return msg;
 
 ## 场景控制
 
+> 💾 已保存的场景何时写入磁盘由 KNX 网关的**文件缓存控制**决定。选择**禁用写入**时，这些数据仅保存在内存中，每次重启 Node-RED 都会丢失。 参见 KNX 网关的**文件缓存控制**选项卡。
+
 ### Scene Controller（场景控制器）
 
 该节点与 KNX 场景控制器一致：可以保存和召回场景。

package/nodes/locales/zh-CN/knxUltimateViewer.html

@@ -19,6 +19,8 @@ Read 请求也会保存在 24 小时历史记录中，但不显示上一个值
 
 运行中的 Viewer 节点会自动将历史记录保存到 `userDir/knxultimatestorage/viewer` 目录下的文件中，并按 Viewer 和网关分别存储。超过 24 小时的变化记录会自动清除。Node-RED 重启后，Viewer 会恢复仍在此时间范围内的历史记录。
 
+> 💾 历史记录文件何时写入磁盘由 KNX 网关的**文件缓存控制**决定。选择**禁用写入**时，这些数据仅保存在内存中，每次重启 Node-RED 都会丢失。 参见 KNX 网关的**文件缓存控制**选项卡。
+
 更新后的 Viewer 部署并运行后才会开始记录，不会补录此前的总线流量。
 
 ## 流程输出

package/nodes/utils/fileStorage.js

@@ -0,0 +1,376 @@
+// File Cache Control: every file written by this package goes through this module.
+// The Winston log is the only exception, as it is governed by the log level.
+//
+// Each gateway (knxUltimate-config) owns one storage. Nodes write to it as usual,
+// but the data is kept in memory and committed to disk according to the
+// gateway's "disk-wearing" mode:
+//   freshness - pending changes are committed every 5 seconds
+//   balanced  - pending changes are committed when the gateway connects or disconnects
+//   custom    - pending changes are committed at a user defined interval (5 s .. 30 days)
+//   disabled  - nothing is ever written: the data lives in memory until Node-RED restarts
+// Reads always see pending data, and write failures never reach the nodes:
+// whatever the mode, a node behaves as if its data had been saved.
+const fs = require('fs')
+const path = require('path')
+
+const MODES = ['freshness', 'balanced', 'disabled', 'custom']
+const FRESHNESS_INTERVAL_MS = 5000
+const MIN_INTERVAL_SECONDS = 5
+const MAX_INTERVAL_SECONDS = 30 * 24 * 60 * 60
+const UNIT_SECONDS = { s: 1, m: 60, h: 60 * 60, d: 24 * 60 * 60 }
+// setInterval cannot wait longer than 2^31-1 ms (about 24.8 days): longer
+// intervals are checked every hour instead.
+const MAX_TIMER_MS = 2 ** 31 - 1
+const LONG_INTERVAL_CHECK_MS = 60 * 60 * 1000
+// Appended data (e.g. the Viewer history) can grow without limits between two
+// commits. Past this size it is committed early or, when writing is disabled,
+// its oldest chunks are dropped.
+const MAX_PENDING_APPEND_BYTES = 8 * 1024 * 1024
+// After a gateway redeploy, a storage in "disabled" mode hands its data over to
+// the next instance of the same gateway, so only a Node-RED restart loses it.
+const HANDOVER_TTL_MS = 60 * 1000
+const NEWLINE = Buffer.from('\n')
+
+const handovers = new Map()
+
+function resolveSettings ({ mode, interval, intervalUnit } = {}) {
+  const resolvedMode = MODES.includes(mode) ? mode : 'freshness'
+  // Missing values (gateways saved by older versions) default to 10 minutes, as in the editor.
+  const amount = interval === '' || interval === null || interval === undefined ? NaN : Number(interval)
+  let seconds = amount * (UNIT_SECONDS[intervalUnit] || UNIT_SECONDS.m)
+  if (!Number.isFinite(seconds)) seconds = 10 * 60
+  seconds = Math.min(MAX_INTERVAL_SECONDS, Math.max(MIN_INTERVAL_SECONDS, Math.round(seconds)))
+  let intervalMs = 0
+  if (resolvedMode === 'freshness') intervalMs = FRESHNESS_INTERVAL_MS
+  if (resolvedMode === 'custom') intervalMs = seconds * 1000
+  return { mode: resolvedMode, intervalMs }
+}
+
+function toBuffer (data) {
+  const value = typeof data === 'function' ? data() : data
+  return Buffer.isBuffer(value) ? value : Buffer.from(String(value === undefined || value === null ? '' : value))
+}
+
+function notFound (filePath) {
+  const error = new Error(`ENOENT: no such file or directory, open '${filePath}'`)
+  error.code = 'ENOENT'
+  error.path = filePath
+  return error
+}
+
+function readDisk (filePath) {
+  try { return fs.readFileSync(filePath) } catch (error) {
+    if (error.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+function endsWithNewline (filePath) {
+  let descriptor
+  try {
+    descriptor = fs.openSync(filePath, 'r')
+    const { size } = fs.fstatSync(descriptor)
+    if (size === 0) return true
+    const last = Buffer.alloc(1)
+    fs.readSync(descriptor, last, 0, 1, size - 1)
+    return last[0] === 10
+  } catch (error) {
+    if (error.code === 'ENOENT') return true
+    throw error
+  } finally {
+    if (descriptor !== undefined) fs.closeSync(descriptor)
+  }
+}
+
+// The only function of the package that modifies files on disk.
+function commitFileOperation ({ type, filePath, data, options = {} }) {
+  if (type === 'delete') {
+    fs.rmSync(filePath, { force: true })
+    return
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: options.dirMode })
+  if (type === 'write') {
+    // Replace through a sibling file, so a crash never leaves a truncated file.
+    const temporary = filePath + '.knxtmp'
+    fs.writeFileSync(temporary, toBuffer(data), { mode: options.mode })
+    fs.renameSync(temporary, filePath)
+    return
+  }
+  let chunk = toBuffer(data)
+  // A previously interrupted append leaves half a line: keep it on its own
+  // line, so the data appended now stays readable.
+  if (options.newlineDelimited && !endsWithNewline(filePath)) chunk = Buffer.concat([NEWLINE, chunk])
+  fs.appendFileSync(filePath, chunk, { mode: options.mode })
+}
+
+class FileStorage {
+  constructor ({ ownerId, mode, interval, intervalUnit, log } = {}) {
+    const settings = resolveSettings({ mode, interval, intervalUnit })
+    this.ownerId = ownerId
+    this.mode = settings.mode
+    this.intervalMs = settings.intervalMs
+    this.log = typeof log === 'function' ? log : () => {}
+    // Without an owner the storage commits immediately and reports errors to
+    // the caller. It is used by nodes without a gateway and after a close.
+    this.direct = mode === 'direct'
+    this.closed = false
+    this.pending = new Map()
+    this.pendingAppendBytes = 0
+    this.sequence = 0
+    this.lastError = ''
+    this.lastFailureAt = 0
+    this.timer = null
+    this.adoptHandover()
+    this.lastFlushAt = Date.now()
+    if (!this.direct && this.intervalMs > 0) {
+      this.timer = this.intervalMs <= MAX_TIMER_MS
+        ? setInterval(() => this.flush(), this.intervalMs)
+        : setInterval(() => { if (Date.now() - this.lastFlushAt >= this.intervalMs) this.flush() }, LONG_INTERVAL_CHECK_MS)
+      if (typeof this.timer?.unref === 'function') this.timer.unref()
+    }
+  }
+
+  get writable () {
+    return this.mode !== 'disabled'
+  }
+
+  get immediate () {
+    return this.direct || this.closed
+  }
+
+  adoptHandover () {
+    const now = Date.now()
+    for (const [ownerId, handover] of handovers) {
+      if (now - handover.closedAt > HANDOVER_TTL_MS) handovers.delete(ownerId)
+    }
+    const handover = this.ownerId !== undefined ? handovers.get(this.ownerId) : undefined
+    if (!handover) return
+    handovers.delete(this.ownerId)
+    this.pending = handover.pending
+    this.pendingAppendBytes = handover.pendingAppendBytes
+  }
+
+  // Replaces the whole file. `data` can be a function: it is evaluated only
+  // when the file is committed or read, so frequent updates cost nothing.
+  writeFile (filePath, data, options = {}) {
+    this.enqueue(filePath, { kind: 'write', data, options })
+  }
+
+  appendFile (filePath, data, options = {}) {
+    if (this.immediate) {
+      if (this.writable) commitFileOperation({ type: 'append', filePath, data, options })
+      return
+    }
+    const chunk = toBuffer(data)
+    const entry = this.pending.get(filePath)
+    if (entry && entry.kind === 'append') {
+      entry.chunks.push(chunk)
+      entry.bytes += chunk.length
+      this.pendingAppendBytes += chunk.length
+    } else if (entry) {
+      // Appending to replaced or deleted content is a replacement too.
+      const base = entry.kind === 'write' ? toBuffer(entry.data) : Buffer.alloc(0)
+      this.pending.set(filePath, { kind: 'write', data: Buffer.concat([base, chunk]), options: { ...entry.options, ...options } })
+    } else {
+      this.pending.set(filePath, { kind: 'append', chunks: [chunk], bytes: chunk.length, options, sequence: ++this.sequence })
+      this.pendingAppendBytes += chunk.length
+    }
+    this.enforceAppendBudget()
+  }
+
+  deleteFile (filePath) {
+    // A file that exists only in memory has nothing to delete on disk.
+    if (!this.immediate && !fs.existsSync(filePath)) {
+      this.forget(filePath)
+      return
+    }
+    this.enqueue(filePath, { kind: 'delete', options: {} })
+  }
+
+  enqueue (filePath, entry) {
+    if (this.immediate) {
+      if (this.writable) commitFileOperation({ type: entry.kind, filePath, data: entry.data, options: entry.options })
+      return
+    }
+    this.forget(filePath)
+    this.pending.set(filePath, entry)
+  }
+
+  forget (filePath) {
+    const entry = this.pending.get(filePath)
+    if (entry && entry.kind === 'append') this.pendingAppendBytes -= entry.bytes
+    this.pending.delete(filePath)
+  }
+
+  enforceAppendBudget () {
+    if (this.pendingAppendBytes <= MAX_PENDING_APPEND_BYTES) return
+    if (this.writable && Date.now() - this.lastFailureAt > FRESHNESS_INTERVAL_MS) this.flush()
+    // Still too much data (writing disabled or failing): drop the oldest chunks.
+    while (this.pendingAppendBytes > MAX_PENDING_APPEND_BYTES) {
+      let oldest
+      for (const [filePath, entry] of this.pending) {
+        if (entry.kind === 'append' && (!oldest || entry.sequence < oldest.entry.sequence)) oldest = { filePath, entry }
+      }
+      if (!oldest) return
+      const dropped = oldest.entry.chunks.shift()
+      oldest.entry.bytes -= dropped.length
+      this.pendingAppendBytes -= dropped.length
+      if (oldest.entry.chunks.length === 0) this.pending.delete(oldest.filePath)
+    }
+  }
+
+  // Content of a pending append: what is on disk followed by the pending chunks.
+  appendedContent (filePath, entry) {
+    const disk = readDisk(filePath) || Buffer.alloc(0)
+    const parts = [disk]
+    if (entry.options.newlineDelimited && disk.length > 0 && disk[disk.length - 1] !== 10) parts.push(NEWLINE)
+    return Buffer.concat(parts.concat(entry.chunks))
+  }
+
+  readFile (filePath, encoding) {
+    const entry = this.pending.get(filePath)
+    let content
+    if (!entry) return fs.readFileSync(filePath, encoding)
+    if (entry.kind === 'delete') throw notFound(filePath)
+    if (entry.kind === 'write') content = toBuffer(entry.data)
+    else content = this.appendedContent(filePath, entry)
+    return encoding ? content.toString(encoding) : content
+  }
+
+  exists (filePath) {
+    const entry = this.pending.get(filePath)
+    if (entry) return entry.kind !== 'delete'
+    return fs.existsSync(filePath)
+  }
+
+  // File names in a directory, pending files included.
+  listDirectory (directory) {
+    const names = new Set()
+    try {
+      fs.readdirSync(directory).forEach(name => names.add(name))
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error
+    }
+    for (const [filePath, entry] of this.pending) {
+      if (path.dirname(filePath) !== directory) continue
+      if (entry.kind === 'delete') names.delete(path.basename(filePath))
+      else names.add(path.basename(filePath))
+    }
+    return Array.from(names)
+  }
+
+  // A read-only snapshot of a file, pending data included, for random-access
+  // reads of large files. Data committed or added later is not visible.
+  async openSnapshot (filePath) {
+    const entry = this.pending.get(filePath)
+    if (entry && entry.kind === 'delete') throw notFound(filePath)
+    let handle = null
+    let diskSize = 0
+    let memory = Buffer.alloc(0)
+    if (entry && entry.kind === 'write') {
+      memory = toBuffer(entry.data)
+    } else {
+      try {
+        handle = await fs.promises.open(filePath, 'r')
+        diskSize = (await handle.stat()).size
+      } catch (error) {
+        if (error.code !== 'ENOENT' || !entry) throw error
+      }
+      if (entry) {
+        const parts = []
+        if (handle && diskSize > 0 && entry.options.newlineDelimited) {
+          const last = Buffer.alloc(1)
+          await handle.read(last, 0, 1, diskSize - 1)
+          if (last[0] !== 10) parts.push(NEWLINE)
+        }
+        memory = Buffer.concat(parts.concat(entry.chunks))
+      }
+    }
+    return {
+      size: diskSize + memory.length,
+      async read (buffer, offset, length, position) {
+        let bytesRead = 0
+        if (handle && position < diskSize) {
+          const result = await handle.read(buffer, offset, Math.min(length, diskSize - position), position)
+          bytesRead = result.bytesRead
+        }
+        const memoryStart = Math.max(0, position + bytesRead - diskSize)
+        if (bytesRead < length && position + bytesRead >= diskSize) {
+          bytesRead += memory.copy(buffer, offset + bytesRead, memoryStart, memoryStart + length - bytesRead)
+        }
+        return { bytesRead }
+      },
+      async close () {
+        if (handle) await handle.close()
+      }
+    }
+  }
+
+  // Commits every pending change. Failed changes stay pending for the next attempt.
+  flush () {
+    this.lastFlushAt = Date.now()
+    if (!this.writable || this.pending.size === 0) return
+    for (const [filePath, entry] of Array.from(this.pending)) {
+      try {
+        if (entry.kind === 'append') {
+          commitFileOperation({ type: 'append', filePath, data: Buffer.concat(entry.chunks), options: entry.options })
+        } else {
+          commitFileOperation({ type: entry.kind, filePath, data: entry.data, options: entry.options })
+        }
+        this.forget(filePath)
+      } catch (error) {
+        this.lastFailureAt = Date.now()
+        const message = `File Cache Control: unable to save ${filePath}: ${error.message}`
+        if (this.lastError !== message) this.log('error', message)
+        this.lastError = message
+      }
+    }
+  }
+
+  // Called by the gateway on every connection and disconnection.
+  handleGatewayEvent () {
+    if (this.mode === 'balanced') this.flush()
+  }
+
+  close () {
+    if (this.closed) return
+    if (this.timer !== null) clearInterval(this.timer)
+    this.timer = null
+    if (this.writable) {
+      this.flush()
+    } else if (this.ownerId !== undefined && this.pending.size > 0) {
+      // Serialize now: the data of a closed node must not be kept alive.
+      for (const entry of this.pending.values()) {
+        if (entry.kind === 'write') entry.data = toBuffer(entry.data)
+      }
+      handovers.set(this.ownerId, { pending: this.pending, pendingAppendBytes: this.pendingAppendBytes, closedAt: Date.now() })
+    }
+    this.pending = new Map()
+    this.pendingAppendBytes = 0
+    // Late writes (e.g. nodes closing after their gateway) are committed at once.
+    this.closed = true
+  }
+}
+
+const directStorage = new FileStorage({ mode: 'direct' })
+
+function createFileStorage (options) {
+  return new FileStorage(options)
+}
+
+// The storage of a gateway node, or the direct one when there is no gateway.
+function storageOf (gateway) {
+  return gateway && gateway.fileStorage instanceof FileStorage ? gateway.fileStorage : directStorage
+}
+
+module.exports = {
+  createFileStorage,
+  storageOf,
+  resolveSettings,
+  directStorage,
+  FileStorage,
+  MODES,
+  MIN_INTERVAL_SECONDS,
+  MAX_INTERVAL_SECONDS,
+  MAX_PENDING_APPEND_BYTES
+}

package/nodes/utils/knxUtilityProfiles/runtime/autoresponder.js

@@ -1,9 +1,9 @@
 // Private KNX Utility profile. Independent of the legacy palette entry point.
 const loggerClass = require('../../sysLogger')
+const { storageOf } = require('../../fileStorage')
 
 module.exports = function (RED) {
   const dptlib = require('knxultimate').dptlib
-  const fs = require('fs')
   const path = require('path')
 
   // msg is:
@@ -51,7 +51,6 @@ module.exports = function (RED) {
     node.inputRBE = 'false' // Apply or not RBE to the input (Messages coming from BUS)
     node.exposedGAs = []
     node.commandText = [] // Raw list Respond To
-    node.timerSaveExposedGAs = null
 
     const pushStatus = (status) => {
       if (!status) return
@@ -86,21 +85,24 @@ module.exports = function (RED) {
       // }
     }
 
-    node.saveExposedGAs = async () => {
-      const sFile = path.join(node.serverKNX.userDir, 'knxpersistvalues', 'knxpersist' + node.id + '.json')
+    // The gateway's File Cache Control decides when the values reach the disk.
+    const storage = storageOf(node.serverKNX)
+    const persistFile = path.join(node.serverKNX.userDir, 'knxpersistvalues', 'knxpersist' + node.id + '.json')
+    node.saveExposedGAs = (snapshot = false) => {
       try {
         // An empty configured list must also replace its previous saved values.
-        fs.writeFileSync(sFile, JSON.stringify(node.exposedGAs))
-        if (node.sysLogger !== undefined && node.sysLogger !== null) node.sysLogger.info('knxUltimateAutoResponder: wrote peristent values to the file ' + sFile)
+        // A snapshot is serialized now, as the list is about to be discarded.
+        const serialize = () => JSON.stringify(node.exposedGAs)
+        storage.writeFile(persistFile, snapshot ? serialize() : serialize)
       } catch (err) {
-        if (node.sysLogger !== undefined && node.sysLogger !== null) node.sysLogger.error('knxUltimateAutoResponder: unable to write peristent values to the file ' + sFile + ' ' + err.message)
+        if (node.sysLogger !== undefined && node.sysLogger !== null) node.sysLogger.error('knxUltimateAutoResponder: unable to write peristent values to the file ' + persistFile + ' ' + err.message)
       }
     }
 
     node.loadExposedGAs = () => {
-      const sFile = path.join(node.serverKNX.userDir, 'knxpersistvalues', 'knxpersist' + node.id + '.json')
+      const sFile = persistFile
       try {
-        node.exposedGAs = JSON.parse(fs.readFileSync(sFile, 'utf8'))
+        node.exposedGAs = JSON.parse(storage.readFile(sFile, 'utf8'))
       } catch (err) {
         node.exposedGAs = []
         if (node.sysLogger !== undefined && node.sysLogger !== null) node.sysLogger.warn('knxUltimateAutoResponder: unable to read peristent file ' + sFile + ' ' + err.message)
@@ -183,6 +185,7 @@ module.exports = function (RED) {
     // inside the loop discards persisted payloads belonging to later entries;
     // skipping this step for [] leaves removed addresses able to respond.
     node.exposedGAs = node.exposedGAs.filter(ga => ga.enabled === true)
+    node.saveExposedGAs()
 
     // This function is called by the knx-ultimate config node, to output a msg.payload.
     node.handleSend = msg => {
@@ -203,7 +206,9 @@ module.exports = function (RED) {
             updateStatus({ fill: 'red', shape: 'dot', text: 'const decodedPayload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(oGa.dpt)); ' + error.message, payload: '', dpt: '', devicename: '' })
             if (node.sysLogger !== undefined && node.sysLogger !== null) node.sysLogger.error(`knxUltimateAutoResponder: const decodedPayload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(oGa.dpt)); ${error.stack}`)
           }
+          const changed = JSON.stringify(oGa.payload) !== JSON.stringify(decodedPayload)
           oGa.payload = decodedPayload
+          if (changed) node.saveExposedGAs()
         }
       } else {
         try {
@@ -238,11 +243,7 @@ module.exports = function (RED) {
     })
 
     node.on('close', function (done) {
-      try {
-        if (node.timerSaveExposedGAs !== null) clearInterval(node.timerSaveExposedGAs)
-        node.saveExposedGAs()
-      } catch (error) {
-      }
+      node.saveExposedGAs(true)
 
       node.exposedGAs = []
       if (node.serverKNX) {
@@ -256,11 +257,6 @@ module.exports = function (RED) {
       node.serverKNX.removeClient(node)
       node.serverKNX.addClient(node)
     }
-    // Start persistence only after configuration and close handling are ready.
-    // Invalid JSON must not leave an interval alive on an inactive profile.
-    node.timerSaveExposedGAs = setInterval(async () => {
-      await node.saveExposedGAs()
-    }, 5000)
   }
   RED.nodes.registerType('knxUltimateAutoResponder', knxUltimateAutoResponder)
 }

package/nodes/utils/knxUtilityProfiles/runtime/logger.js

@@ -1,6 +1,6 @@
 // Private KNX Utility profile. Independent of the legacy palette entry point.
 const createProfileTimers = require('./profileTimers')
-const fs = require('fs')
+const { storageOf } = require('../../fileStorage')
 
 module.exports = function (RED) {
   function knxUltimateLogger (config) {
@@ -80,11 +80,14 @@ module.exports = function (RED) {
       return header + lines.join('') + stop + closing
     }
 
+    // The gateway's File Cache Control decides when the file reaches the disk.
+    const storage = storageOf(node.serverKNX)
+
     const readExistingTelegramLines = () => {
       if (node.saveMode !== 'emit_save' || node.filePath === '') return []
-      if (!fs.existsSync(node.filePath)) return []
+      if (!storage.exists(node.filePath)) return []
       try {
-        const fileContent = fs.readFileSync(node.filePath, 'utf8')
+        const fileContent = storage.readFile(node.filePath, 'utf8')
         const lines = fileContent.split(/\r?\n/).map(l => l + '\n') // keep newline
         const telegramLines = []
         let inLog = false
@@ -121,7 +124,7 @@ module.exports = function (RED) {
             allLines = allLines.slice(allLines.length - node.maxRowsInETSXML)
           }
           const fileContent = buildXMLFromLines(allLines)
-          fs.writeFileSync(node.filePath, fileContent, { encoding: 'utf8' })
+          storage.writeFile(node.filePath, fileContent)
           statusText = 'Payload ETS sent and saved.'
         } catch (error) {
           node.error(`knxUltimateLogger: error writing file ${node.filePath}: ${error.message}`)