data-solectrus 0.2.10

package/lib/services/tickRunner.js

@@ -0,0 +1,282 @@
+'use strict';
+
+// Tick scheduler + runtime loop.
+// Keeps timing and error-policy in one place, away from main.js.
+
+const itemManager = require('./itemManager');
+const snapshotService = require('./snapshot');
+const evaluator = require('./evaluator');
+const { getItemOutputId } = require('./itemIds');
+const stateRegistry = require('./stateRegistry');
+
+function getTickIntervalMs(adapter) {
+	const fallbackSeconds = 5;
+	const cfgSecondsRaw = adapter.config && adapter.config.pollIntervalSeconds !== undefined
+		? adapter.config.pollIntervalSeconds
+		: fallbackSeconds;
+	const cfgSeconds = Number(cfgSecondsRaw);
+
+	// Keep it sane; Admin enforces min/max but we also guard here.
+	const seconds = Number.isFinite(cfgSeconds) && cfgSeconds > 0 ? cfgSeconds : fallbackSeconds;
+	return Math.round(seconds * 1000);
+}
+
+function getTickTimeBudgetMs(adapter) {
+	const interval = getTickIntervalMs(adapter);
+	const ratioRaw = Number(adapter.TICK_TIME_BUDGET_RATIO);
+	const ratio = Number.isFinite(ratioRaw) && ratioRaw > 0 && ratioRaw <= 1 ? ratioRaw : 0.8;
+	return Math.max(0, Math.floor(interval * ratio));
+}
+
+function getErrorRetriesBeforeZero(adapter) {
+	const raw = adapter.config && adapter.config.errorRetriesBeforeZero !== undefined
+		? adapter.config.errorRetriesBeforeZero
+		: 3;
+	const n = Number(raw);
+	if (!Number.isFinite(n) || n < 0) return 3;
+	return Math.min(100, Math.round(n));
+}
+
+function isInputTsGapDiagnosticsEnabled(adapter) {
+	const raw = adapter.config && adapter.config.enableInputTsGapDiagnostics !== undefined
+		? adapter.config.enableInputTsGapDiagnostics
+		: true;
+	if (raw === false || raw === 0 || raw === '0' || raw === 'false') return false;
+	return true;
+}
+
+async function runTick(adapter) {
+	const start = Date.now();
+	const items = Array.isArray(adapter.config.items) ? adapter.config.items : [];
+	const enabledItems = items.filter(it => it && typeof it === 'object' && it.enabled);
+	const retriesBeforeZero = getErrorRetriesBeforeZero(adapter);
+	const timeBudgetMs = getTickTimeBudgetMs(adapter);
+	let skippedItems = 0;
+
+	// If config changed (without restart), rebuild compiled cache + subscriptions.
+	try {
+		await itemManager.ensureCompiledForCurrentConfig(adapter, items);
+	} catch (e) {
+		const msg = e && e.message ? e.message : String(e);
+		adapter.log.warn(`Prepare items failed: ${msg}`);
+		try {
+			await adapter.setStateAsync('info.lastError', msg, true);
+		} catch {
+			// ignore
+		}
+	}
+
+	// Keep status in sync even if config changes without a restart
+	try {
+		await adapter.setStateAsync('info.diagnostics.itemsTotal', items.filter(it => it && typeof it === 'object').length, true);
+		await adapter.setStateAsync('info.itemsActive', enabledItems.length, true);
+		await adapter.setStateAsync('info.status', enabledItems.length ? 'ok' : 'no_items_enabled', true);
+		await adapter.setStateAsync('info.diagnostics.evalBudgetMs', timeBudgetMs, true);
+		await adapter.setStateAsync('info.diagnostics.evalSkipped', 0, true);
+	} catch {
+		// ignore
+	}
+
+	let snapshot = null;
+	try {
+		snapshot = await snapshotService.buildSnapshotForTick(adapter, items);
+	} catch (e) {
+		const msg = e && e.message ? e.message : String(e);
+		adapter.log.warn(`Snapshot build failed: ${msg}`);
+		try {
+			await adapter.setStateAsync('info.lastError', msg, true);
+		} catch {
+			// ignore
+		}
+		snapshot = new Map();
+	}
+	adapter.currentSnapshot = snapshot;
+
+	// Publish input timestamp skew diagnostics.
+	// This helps explain "impossible" transient combinations when snapshot is off or sources update slightly offset.
+	try {
+		const enabled = isInputTsGapDiagnosticsEnabled(adapter);
+		if (!enabled) {
+			// Keep other diagnostics untouched when disabled.
+		} else {
+		const ids = snapshot && typeof snapshot.keys === 'function' ? Array.from(snapshot.keys()) : [];
+		const now = Date.now();
+		let minTs = Infinity;
+		let maxTs = -Infinity;
+		let minId = '';
+		let maxId = '';
+		let withTs = 0;
+		let total = 0;
+		/** @type {Array<{id:string, ts:number, ageMs:number}>} */
+		const entries = [];
+		for (const id of ids) {
+			if (!id) continue;
+			total++;
+			const ts = adapter.cacheTs.get(id);
+			if (typeof ts !== 'number' || !Number.isFinite(ts)) continue;
+			withTs++;
+			const ageMs = Math.max(0, Math.round(now - ts));
+			entries.push({ id: String(id), ts, ageMs });
+			if (ts < minTs) {
+				minTs = ts;
+				minId = String(id);
+			}
+			if (ts > maxTs) {
+				maxTs = ts;
+				maxId = String(id);
+			}
+		}
+		const gapMs = withTs >= 2 ? Math.max(0, Math.round(maxTs - minTs)) : 0;
+		const intervalMs = getTickIntervalMs(adapter);
+		const thresholdMs = Math.max(200, Math.min(5000, Math.floor(intervalMs * 0.2)));
+		const ok = withTs <= 1 ? true : gapMs <= thresholdMs;
+
+		// "Active" inputs are those that updated recently; slow/sleeping inputs can otherwise dominate the gap.
+		const activeAgeThresholdMs = Math.max(intervalMs * 2, 30_000);
+		let activeMinTs = Infinity;
+		let activeMaxTs = -Infinity;
+		let activeCount = 0;
+		for (const e of entries) {
+			if (e.ageMs > activeAgeThresholdMs) continue;
+			activeCount++;
+			if (e.ts < activeMinTs) activeMinTs = e.ts;
+			if (e.ts > activeMaxTs) activeMaxTs = e.ts;
+		}
+		const activeGapMs = activeCount >= 2 ? Math.max(0, Math.round(activeMaxTs - activeMinTs)) : 0;
+		const activeOk = activeCount <= 1 ? true : activeGapMs <= thresholdMs;
+		const sleeping = Math.max(0, withTs - activeCount);
+
+		const oldestAgeMs = withTs >= 1 ? Math.max(0, Math.round(now - minTs)) : 0;
+		const newestAgeMs = withTs >= 1 ? Math.max(0, Math.round(now - maxTs)) : 0;
+
+		await adapter.setStateAsync('info.diagnostics.timing.gapMs', gapMs, true);
+		await adapter.setStateAsync('info.diagnostics.timing.gapOk', ok, true);
+		await adapter.setStateAsync('info.diagnostics.timing.gapActiveMs', activeGapMs, true);
+		await adapter.setStateAsync('info.diagnostics.timing.gapActiveOk', activeOk, true);
+		await adapter.setStateAsync('info.diagnostics.timing.sources', withTs, true);
+		await adapter.setStateAsync('info.diagnostics.timing.sourcesActive', activeCount, true);
+		await adapter.setStateAsync('info.diagnostics.timing.sourcesSleeping', sleeping, true);
+		await adapter.setStateAsync('info.diagnostics.timing.oldestId', minId, true);
+		await adapter.setStateAsync('info.diagnostics.timing.oldestAgeMs', oldestAgeMs, true);
+		await adapter.setStateAsync('info.diagnostics.timing.newestId', maxId, true);
+		await adapter.setStateAsync('info.diagnostics.timing.newestAgeMs', newestAgeMs, true);
+		}
+	} catch {
+		// ignore
+	}
+
+	for (let idx = 0; idx < enabledItems.length; idx++) {
+		const item = enabledItems[idx];
+		if (timeBudgetMs > 0 && (Date.now() - start) > timeBudgetMs) {
+			skippedItems = enabledItems.length - idx;
+			adapter.warnOnce(
+				`tick_budget_exceeded|${Math.floor(Date.now() / 60000)}`,
+				`Tick time budget exceeded (${timeBudgetMs}ms). Skipping ${skippedItems} remaining item(s) this tick.`
+			);
+			break;
+		}
+
+		const targetId = getItemOutputId(item);
+		if (!targetId) continue;
+		const itemStart = Date.now();
+		const itemInfoBase = stateRegistry.getItemInfoBaseId(targetId);
+
+		try {
+			const raw = await evaluator.computeItemValue(adapter, item, snapshot);
+			const shaped = evaluator.isNumericOutputItem(item)
+				? evaluator.applyResultRules(adapter, item, raw)
+				: raw;
+			const value = evaluator.castValueForItemType(adapter, item, shaped);
+
+			await adapter.setStateAsync(targetId, value, true);
+			adapter.lastGoodValue.set(targetId, value);
+			adapter.lastGoodTs.set(targetId, Date.now());
+			adapter.consecutiveErrorCounts.set(targetId, 0);
+
+			// Per-item info states (best-effort; must never break tick)
+			try {
+				await adapter.setStateAsync(`${itemInfoBase}.lastOkTs`, new Date().toISOString(), true);
+				await adapter.setStateAsync(`${itemInfoBase}.lastEvalMs`, Date.now() - itemStart, true);
+				await adapter.setStateAsync(`${itemInfoBase}.lastError`, '', true);
+				await adapter.setStateAsync(`${itemInfoBase}.consecutiveErrors`, 0, true);
+			} catch {
+				// ignore
+			}
+		} catch (e) {
+			const name = item.name || targetId;
+			const errMsg = e && e.message ? e.message : String(e);
+			const msg = `${name}: ${errMsg}`;
+			adapter.warnOnce(`compute_failed|${targetId}`, `Compute failed (will retry/keep last): ${msg}`);
+			try {
+				await adapter.setStateAsync('info.lastError', msg, true);
+			} catch {
+				// ignore
+			}
+
+			const prev = adapter.consecutiveErrorCounts.get(targetId) || 0;
+			const next = prev + 1;
+			adapter.consecutiveErrorCounts.set(targetId, next);
+			try {
+				await adapter.setStateAsync(`${itemInfoBase}.lastError`, errMsg, true);
+				await adapter.setStateAsync(`${itemInfoBase}.lastEvalMs`, Date.now() - itemStart, true);
+				await adapter.setStateAsync(`${itemInfoBase}.consecutiveErrors`, next, true);
+			} catch {
+				// ignore
+			}
+
+			// Policy: keep last good value for N retries, then set to 0.
+			if (adapter.lastGoodValue.has(targetId) && next <= retriesBeforeZero) {
+				try {
+					await adapter.setStateAsync(targetId, adapter.lastGoodValue.get(targetId), true);
+				} catch {
+					// ignore write errors
+				}
+			} else if (next > retriesBeforeZero) {
+				try {
+					await adapter.setStateAsync(targetId, evaluator.getZeroValueForItem(item), true);
+				} catch {
+					// ignore write errors
+				}
+			}
+		}
+	}
+
+	adapter.currentSnapshot = null;
+
+	try {
+		await adapter.setStateAsync('info.diagnostics.evalSkipped', skippedItems, true);
+		await adapter.setStateAsync('info.lastRun', new Date().toISOString(), true);
+		await adapter.setStateAsync('info.lastRunMs', Date.now() - start, true);
+	} catch {
+		// ignore
+	}
+}
+
+function scheduleNextTick(adapter) {
+	if (adapter.isUnloading) return;
+	const interval = getTickIntervalMs(adapter);
+	const now = Date.now();
+	const delay = interval - (now % interval);
+
+	if (adapter.tickTimer) {
+		clearTimeout(adapter.tickTimer);
+		adapter.tickTimer = null;
+	}
+
+	adapter.tickTimer = setTimeout(() => {
+		runTick(adapter)
+			.catch(e => {
+				const msg = e && e.message ? e.message : String(e);
+				adapter.log.error(`Tick failed: ${msg}`);
+				adapter.setState('info.lastError', msg, true);
+			})
+			.finally(() => scheduleNextTick(adapter));
+	}, delay);
+}
+
+module.exports = {
+	scheduleNextTick,
+	runTick,
+	getTickIntervalMs,
+	getTickTimeBudgetMs,
+};

package/main.js

@@ -0,0 +1,253 @@
+'use strict';
+
+const utils = require('@iobroker/adapter-core');
+const {
+	parseExpression,
+	normalizeFormulaExpression: normalizeFormulaExpressionImpl,
+	analyzeAst: analyzeAstImpl,
+	evalFormulaAst: evalFormulaAstImpl,
+} = require('./lib/formula');
+const {
+	applyJsonPath: applyJsonPathImpl,
+	getNumericFromJsonPath: getNumericFromJsonPathImpl,
+	getValueFromJsonPath: getValueFromJsonPathImpl,
+} = require('./lib/jsonpath');
+
+const stateRegistry = require('./lib/services/stateRegistry');
+const itemManager = require('./lib/services/itemManager');
+const tickRunner = require('./lib/services/tickRunner');
+const evaluator = require('./lib/services/evaluator');
+
+class DataSolectrus extends utils.Adapter {
+	constructor(options) {
+		super({
+			...options,
+			name: 'data-solectrus',
+		});
+
+		// Hard limits to keep formula evaluation predictable even with hostile/mistyped configs.
+		this.MAX_FORMULA_LENGTH = 8000;
+		this.MAX_AST_NODES = 2000;
+		this.MAX_AST_DEPTH = 60;
+		this.MAX_DISCOVERED_STATE_IDS_PER_ITEM = 250;
+		// Global caps to keep runtime behavior predictable even with huge configs.
+		this.MAX_TOTAL_SOURCE_IDS = 5000;
+		this.TICK_TIME_BUDGET_RATIO = 0.8;
+
+		this.cache = new Map();
+		this.cacheTs = new Map();
+		// Precompiled per-item cache to keep tick evaluation fast and robust.
+		/** @type {Map<string, {ok:boolean, error?:string, item:any, outputId:string, mode:string, sourceIds:Set<string>, normalizedExpr?:string, ast?:any, constantValue?:any}>} */
+		this.compiledItems = new Map();
+		this.itemsConfigSignature = '';
+		this.subscribedIds = new Set();
+		this.lastGoodValue = new Map();
+		this.lastGoodTs = new Map();
+		this.consecutiveErrorCounts = new Map();
+
+		this.currentSnapshot = null;
+		this.tickTimer = null;
+		this.isUnloading = false;
+		this.jsonPathWarned = new Set();
+		this.debugOnceKeys = new Set();
+
+		// Formula helpers are intentionally small and deterministic.
+		// They can read from the tick snapshot (preferred) or the event cache.
+		this.formulaFunctions = evaluator.createFormulaFunctions(this);
+
+		this.on('ready', this.onReady.bind(this));
+		this.on('unload', this.onUnload.bind(this));
+		this.on('stateChange', this.onStateChange.bind(this));
+		this.on('message', this.onMessage.bind(this));
+	}
+
+	onMessage(obj) {
+		try {
+			if (!obj || !obj.command) return;
+			if (obj.command !== 'evalFormulaPreview') return;
+
+			const msg = obj.message && typeof obj.message === 'object' ? obj.message : {};
+			const expr = msg && msg.expr !== undefined ? String(msg.expr) : '';
+			const varsIn = msg && msg.vars && typeof msg.vars === 'object' ? msg.vars : {};
+
+			const safeVars = Object.create(null);
+			let keys = [];
+			try {
+				keys = Object.keys(varsIn);
+			} catch {
+				keys = [];
+			}
+
+			// Keep previews cheap and robust.
+			const MAX_PREVIEW_VARS = 200;
+			for (let i = 0; i < keys.length && i < MAX_PREVIEW_VARS; i++) {
+				const kRaw = keys[i];
+				const k = String(kRaw);
+				if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(k)) continue;
+				if (k === '__proto__' || k === 'prototype' || k === 'constructor') continue;
+
+				const v = varsIn[kRaw];
+				if (typeof v === 'string') {
+					safeVars[k] = v.length > 2000 ? v.slice(0, 2000) : v;
+					continue;
+				}
+				if (typeof v === 'number' || typeof v === 'boolean' || v === null || v === undefined) {
+					safeVars[k] = v;
+					continue;
+				}
+				// For objects/arrays, only allow reasonably-sized JSON.
+				try {
+					const json = JSON.stringify(v);
+					if (json && json.length <= 5000) {
+						safeVars[k] = v;
+					}
+				} catch {
+					// ignore
+				}
+			}
+
+			let result;
+			try {
+				result = this.evalFormula(expr, safeVars);
+			} catch (e) {
+				const err = e && e.message ? String(e.message) : String(e);
+				if (obj.callback) this.sendTo(obj.from, obj.command, { ok: false, error: err }, obj.callback);
+				return;
+			}
+
+			if (obj.callback) this.sendTo(obj.from, obj.command, { ok: true, value: result }, obj.callback);
+		} catch (e) {
+			try {
+				const err = e && e.message ? String(e.message) : String(e);
+				if (obj && obj.callback) this.sendTo(obj.from, obj.command, { ok: false, error: err }, obj.callback);
+			} catch {
+				// ignore
+			}
+		}
+	}
+
+	safeNum(val, fallback = 0) {
+		const n = Number(val);
+		return Number.isFinite(n) ? n : fallback;
+	}
+
+	warnOnce(key, msg) {
+		const k = String(key);
+		if (this.jsonPathWarned.size > 500) this.jsonPathWarned.clear();
+		if (this.jsonPathWarned.has(k)) return;
+		this.jsonPathWarned.add(k);
+		this.log.warn(msg);
+	}
+
+	debugOnce(key, msg) {
+		const k = String(key);
+		if (this.debugOnceKeys.size > 500) this.debugOnceKeys.clear();
+		if (this.debugOnceKeys.has(k)) return;
+		this.debugOnceKeys.add(k);
+		this.log.debug(msg);
+	}
+
+	/**
+	 * Minimal JSONPath subset evaluator for typical IoT payloads.
+	 * Supported examples:
+	 * - $.apower
+	 * - $.aenergy.by_minute[2]
+	 * - $['temperature']['tC']
+	 *
+	 * Not supported: filters, wildcards, unions, recursive descent, functions.
+	 */
+	applyJsonPath(obj, path) {
+		return applyJsonPathImpl(obj, path);
+	}
+
+	analyzeAst(ast) {
+		return analyzeAstImpl(ast, { maxNodes: this.MAX_AST_NODES, maxDepth: this.MAX_AST_DEPTH });
+	}
+
+	getNumericFromJsonPath(rawValue, jsonPath, warnKeyPrefix = '') {
+		return getNumericFromJsonPathImpl(rawValue, jsonPath, {
+			safeNum: this.safeNum.bind(this),
+			warnOnce: this.warnOnce.bind(this),
+			debugOnce: this.debugOnce.bind(this),
+			warnKeyPrefix,
+		});
+	}
+
+	getValueFromJsonPath(rawValue, jsonPath, warnKeyPrefix = '') {
+		return getValueFromJsonPathImpl(rawValue, jsonPath, {
+			warnOnce: this.warnOnce.bind(this),
+			warnKeyPrefix,
+		});
+	}
+
+	/**
+	 * Normalizes some common non-JS formula syntax into the JS-like operators that `jsep` understands.
+	 * - AND/OR/NOT (case-insensitive) -> && / || / !
+	 * - single '=' (outside strings) -> '=='
+	 *
+	 * This is intentionally conservative and only runs outside quoted strings.
+	 */
+	normalizeFormulaExpression(expr) {
+		return normalizeFormulaExpressionImpl(expr);
+	}
+
+	evalFormula(expr, vars) {
+		const normalized = this.normalizeFormulaExpression(expr);
+		if (normalized && normalized.length > this.MAX_FORMULA_LENGTH) {
+			throw new Error(`Formula too long (>${this.MAX_FORMULA_LENGTH} chars)`);
+		}
+		const ast = parseExpression(String(normalized));
+		this.analyzeAst(ast);
+		return this.evalFormulaAst(ast, vars);
+	}
+
+	evalFormulaAst(ast, vars) {
+		return evalFormulaAstImpl(ast, vars, this.formulaFunctions);
+	}
+
+	async onReady() {
+		this.isUnloading = false;
+		await stateRegistry.cleanupOldInfoStates(this);
+		await stateRegistry.createInfoStates(this);
+
+		// Config compatibility: some Admin/jsonConfig schema versions may store custom-control data
+		// under the control name (e.g. itemsEditor). Always prefer native.items but fall back.
+		const items = Array.isArray(this.config.items) ? this.config.items : [];
+		const itemsEditor = Array.isArray(this.config.itemsEditor) ? this.config.itemsEditor : [];
+		this.config.items = items.length ? items : itemsEditor;
+
+		await itemManager.ensureItemTitlesInInstanceConfig(this);
+		await itemManager.prepareItems(this);
+
+		this.log.info('Adapter started successfully');
+		tickRunner.scheduleNextTick(this);
+	}
+
+	onStateChange(id, state) {
+		if (!state) return;
+		if (id && String(id).startsWith(`${this.namespace}.`)) {
+			return;
+		}
+		this.cache.set(id, state.val);
+		this.cacheTs.set(id, typeof state.ts === 'number' ? state.ts : Date.now());
+	}
+
+	onUnload(callback) {
+		try {
+			this.isUnloading = true;
+			if (this.tickTimer) {
+				clearTimeout(this.tickTimer);
+				this.tickTimer = null;
+			}
+			callback();
+		} catch {
+			callback();
+		}
+	}
+}
+
+if (require.main !== module) {
+	module.exports = options => new DataSolectrus(options);
+} else {
+	(() => new DataSolectrus())();
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "data-solectrus",
+  "version": "0.2.10",
+  "description": "ioBroker adapter to compute/mirror PV & consumption values for SOLECTRUS dashboards",
+  "author": "Sven Griese (Felliglanz)",
+  "main": "main.js",
+  "keywords": [
+    "iobroker",
+    "adapter",
+    "solectrus",
+    "pv",
+    "formula"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Felliglanz/data-solectrus.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Felliglanz/data-solectrus/issues"
+  },
+  "homepage": "https://github.com/Felliglanz/data-solectrus#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@iobroker/adapter-core": "^3.2.3",
+    "jsep": "^1.3.8"
+  },
+  "scripts": {
+    "start": "node main.js",
+    "lint": "node scripts/lint-syntax.js",
+    "smoke": "node scripts/smoke-runtime.js",
+    "check:simulate": "node scripts/check-simulate-30s.js"
+  }
+}