@tetherto/mdk-core 0.0.0 → 0.12.1

package/lib/stats/ops/group_max.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const lUtils = require('../utils')
+
+function groupMax (op, cur, entry, ext) {
+  if (!cur) {
+    cur = { res: lUtils.createResMap() }
+  }
+
+  if (!entry) {
+    return cur
+  }
+
+  if (op.filter && !op.filter(entry)) {
+    return cur
+  }
+
+  if (!op.group) {
+    return cur
+  }
+  const groupName = op.group(entry, ext)
+
+  if (!groupName || !lUtils.isSafeKey(groupName)) {
+    return cur
+  }
+
+  if (!cur.res[groupName]) {
+    cur.res[groupName] = 0
+  }
+
+  const val = lUtils.getVal(entry, op.src) || 0
+
+  cur.res[groupName] = cur.res[groupName] === undefined ? val : Math.max(cur.res[groupName], val)
+
+  return cur
+}
+
+module.exports = {
+  calc: groupMax
+}

package/lib/stats/ops/group_multiple_stats.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const lUtils = require('../utils')
+
+function groupMultipleStats (op, cur, entry, ext) {
+  if (!cur) {
+    cur = { res: lUtils.createResMap() }
+  }
+
+  if (!entry) {
+    return cur
+  }
+
+  if (!op.srcs || !Array.isArray(op.srcs)) {
+    return cur
+  }
+
+  if (op.filter && !op.filter(entry)) {
+    return cur
+  }
+
+  if (!op.group) {
+    return cur
+  }
+  const groupName = op.group(entry, ext)
+
+  if (!groupName || !lUtils.isSafeKey(groupName)) {
+    return cur
+  }
+
+  cur.res[groupName] = op.srcs.reduce(
+    (prev, src) => ({ ...prev, [src.name]: lUtils.getVal(entry, src.src) }),
+    {}
+  )
+  return cur
+}
+
+module.exports = {
+  calc: groupMultipleStats
+}

package/lib/stats/ops/group_sum.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const lUtils = require('../utils')
+
+function groupSum (op, cur, entry, ext) {
+  if (!cur) {
+    cur = { res: lUtils.createResMap() }
+  }
+
+  if (!entry) {
+    return cur
+  }
+
+  if (op.filter && !op.filter(entry)) {
+    return cur
+  }
+
+  if (!op.group) {
+    return cur
+  }
+  const groupName = op.group(entry, ext)
+
+  if (!groupName || !lUtils.isSafeKey(groupName)) {
+    return cur
+  }
+
+  if (!cur.res[groupName]) {
+    cur.res[groupName] = 0
+  }
+
+  const val = lUtils.getVal(entry, op.src)
+
+  cur.res[groupName] += val ? +val : 0
+
+  return cur
+}
+
+module.exports = {
+  calc: groupSum
+}

package/lib/stats/ops/index.js

@@ -0,0 +1,35 @@
+'use strict'
+
+// Static registry of stats ops. Op names come from stats specs (`op.op`,
+// `objOps[].op`, `nestedOps[].op`), so they are never turned into a require
+// path: an unknown name is refused instead of resolved on disk. Entries are
+// lazy because array_obj_calc and nested_obj_concat look ops up themselves.
+const OPS = {
+  alerts_aggr: () => require('./alerts_aggr'),
+  alerts_group_cnt: () => require('./alerts_group_cnt'),
+  arr_concat: () => require('./arr_concat'),
+  array_obj_calc: () => require('./array_obj_calc'),
+  avg: () => require('./avg'),
+  cnt: () => require('./cnt'),
+  group: () => require('./group'),
+  group_avg: () => require('./group_avg'),
+  group_cnt: () => require('./group_cnt'),
+  group_max: () => require('./group_max'),
+  group_multiple_stats: () => require('./group_multiple_stats'),
+  group_sum: () => require('./group_sum'),
+  nested_obj_concat: () => require('./nested_obj_concat'),
+  obj_concat: () => require('./obj_concat'),
+  sum: () => require('./sum')
+}
+
+function getOp (name) {
+  if (typeof name !== 'string' || !Object.hasOwn(OPS, name)) {
+    throw new Error(`ERR_STATS_OP_UNKNOWN: ${String(name).slice(0, 64)}`)
+  }
+  return OPS[name]()
+}
+
+module.exports = {
+  getOp,
+  OP_NAMES: Object.freeze(Object.keys(OPS))
+}

package/lib/stats/ops/nested_obj_concat.js

@@ -0,0 +1,54 @@
+'use strict'
+
+const lUtils = require('../utils')
+const { getOp } = require('./index')
+
+function nestedObjConcat (op, cur, entry, ext) {
+  if (!cur) {
+    cur = { res: lUtils.createResMap() }
+  }
+
+  if (!entry) {
+    return cur
+  }
+
+  if (op.filter && !op.filter(entry)) {
+    return cur
+  }
+
+  const val = lUtils.getVal(entry, op.src)
+  for (const keys in val) {
+    if (!lUtils.isSafeKey(keys)) continue
+    if (!cur.res[keys]) {
+      cur.res[keys] = val[keys]
+    } else {
+      const currObj = cur.res[keys]
+      const newObj = val[keys]
+      if (typeof newObj === 'object' && op.nestedOps) {
+        concatNestedObj(currObj, newObj, op.nestedOps)
+      }
+    }
+  }
+
+  return cur
+}
+
+const concatNestedObj = (currObj, newObj, ops) => {
+  if (!currObj || typeof currObj !== 'object') return
+  for (const key in newObj) {
+    if (!lUtils.isSafeKey(key)) continue
+    const keyOp = ops.find(v => v.src === key)
+    if (keyOp) {
+      const calcFn = getOp(keyOp.op)
+      const calcRes = calcFn.calc(keyOp, currObj[key] && { res: currObj[key] }, newObj)
+      currObj[key] = calcRes.res
+    }
+    if (typeof newObj[key] === 'object' && !Array.isArray(newObj[key])) {
+      concatNestedObj(currObj[key], newObj[key], ops)
+    }
+  }
+}
+
+module.exports = {
+  calc: nestedObjConcat
+}

package/lib/stats/ops/obj_concat.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const lUtils = require('../utils')
+
+function objConcat (op, cur, entry, ext) {
+  if (!cur) {
+    cur = { res: lUtils.createResMap() }
+  }
+
+  if (!entry) {
+    return cur
+  }
+
+  if (op.filter && !op.filter(entry)) {
+    return cur
+  }
+
+  const val = lUtils.getVal(entry, op.src)
+  for (const keys in val) {
+    if (!lUtils.isSafeKey(keys)) continue
+    if (!cur.res[keys]) {
+      cur.res[keys] = val[keys]
+    } else {
+      cur.res[keys] += val[keys]
+    }
+  }
+
+  return cur
+}
+
+module.exports = {
+  calc: objConcat
+}

package/lib/stats/ops/sum.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const lUtils = require('./../utils')
+
+function sum (op, cur, entry, ext) {
+  if (!cur) {
+    cur = { res: 0 }
+  }
+
+  if (!entry) {
+    return cur
+  }
+
+  if (op.filter && !op.filter(entry, ext)) {
+    return cur
+  }
+
+  const val = lUtils.getVal(entry, op.src)
+
+  cur.res += val ? +val : 0
+
+  return cur
+}
+
+module.exports = {
+  calc: sum
+}

package/lib/stats/utils.js

@@ -0,0 +1,99 @@
+'use strict'
+
+// Keypaths are a small, fixed grammar — `a.b.c`, `a[0].b`, `a['k']` — walked
+// segment by segment. They used to be compiled with `new Function`, which made
+// any caller-influenced keypath arbitrary code; the walker below cannot do more
+// than read properties, and refuses the prototype-reaching names outright.
+const FORBIDDEN_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
+const SEGMENT_RE = /^(?:\.?([A-Za-z_$][\w$]*)|\[(\d+)\]|\[(?:'([^'\\]*)'|"([^"\\]*)")\])/
+const MAX_KEYPATH_LENGTH = 512
+const MAX_CACHED_KEYPATHS = 1024
+
+const _parsed = new Map()
+
+function parseKeypath (keypath) {
+  const cached = _parsed.get(keypath)
+  if (cached) return cached
+
+  if (keypath.length > MAX_KEYPATH_LENGTH) throw new Error('ERR_STATS_KEYPATH_INVALID: keypath too long')
+
+  const segments = []
+  let rest = keypath
+  while (rest.length) {
+    const m = SEGMENT_RE.exec(rest)
+    // A leading `.` is only valid between segments, never first.
+    if (!m || (segments.length === 0 && rest[0] === '.')) {
+      throw new Error(`ERR_STATS_KEYPATH_INVALID: ${keypath}`)
+    }
+    const seg = m[1] ?? m[2] ?? m[3] ?? m[4]
+    if (FORBIDDEN_SEGMENTS.has(seg)) {
+      throw new Error(`ERR_STATS_KEYPATH_FORBIDDEN: ${keypath}`)
+    }
+    segments.push(seg)
+    rest = rest.slice(m[0].length)
+  }
+  if (!segments.length) throw new Error(`ERR_STATS_KEYPATH_INVALID: ${keypath}`)
+
+  if (_parsed.size >= MAX_CACHED_KEYPATHS) _parsed.clear()
+  _parsed.set(keypath, segments)
+  return segments
+}
+
+// Same semantics as the old compiled `root.<keypath>` inside try/catch: any
+// missing (null/undefined) link yields undefined instead of throwing.
+function pathResolve (keypath) {
+  const segments = parseKeypath(keypath)
+  return (root) => {
+    let cur = root
+    for (const seg of segments) {
+      if (cur === null || cur === undefined) return undefined
+      cur = cur[seg]
+    }
+    return cur
+  }
+}
+
+function getVal (entry, src) {
+  if (!src) {
+    return null
+  }
+
+  if (typeof src === 'function') {
+    return src(entry)
+  }
+
+  if (typeof src === 'string') {
+    return pathResolve(src)(entry)
+  }
+
+  return null
+}
+
+// Result maps in the stats ops are keyed by data (device `info.container`,
+// alert severities, snapshot object keys). They are created without a
+// prototype and these names are skipped, so a hostile key can neither reach
+// nor pollute Object.prototype.
+function isSafeKey (key) {
+  return typeof key !== 'symbol' && !FORBIDDEN_SEGMENTS.has(String(key))
+}
+
+function createResMap () {
+  return Object.create(null)
+}
+
+const groupBy = (field) => {
+  return (entry, ext) => {
+    if (!ext) {
+      return null
+    }
+    return getVal(ext, field)
+  }
+}
+
+module.exports = {
+  getVal,
+  groupBy,
+  parseKeypath,
+  isSafeKey,
+  createResMap
+}

package/lib/templates/alerts.js

@@ -0,0 +1,128 @@
+'use strict'
+
+const { isValidSnap, isOffline } = require('../utils')
+
+// Base alert spec data per device family. Workers compose their own
+// { specs } template object from these — the exported objects are never
+// mutated: one process can host several worker families, and a mutated module
+// singleton would leak one family's specs into all of them.
+
+function isValidPoolConfigSnap (ctx, snap) {
+  return (
+    isValidSnap(snap) &&
+    !isOffline(snap) &&
+    ctx.thingConf.pools &&
+    ctx.thingConf.pools.length > 0 &&
+    snap.config.pool_config &&
+    snap.config.pool_config.length > 0
+  )
+}
+
+function isIpPoolUsername (ip, minerPools, confPools) {
+  for (let i = 0; i < confPools.length; i++) {
+    const formattedIP = ip.replace(/\./g, 'x')
+    const username = minerPools[i].username
+
+    if (!username.includes(formattedIP)) {
+      return false
+    }
+  }
+  return true
+}
+
+function isCorrectPoolUsername (id, minerPools, confPools) {
+  for (let i = 0; i < confPools.length; i++) {
+    const username = minerPools[i].username
+    if (!username.includes(id)) {
+      return false
+    }
+  }
+  return true
+}
+
+function isConfigWorkerNameInPoolUsername (minerPools, confPools) {
+  for (let i = 0; i < confPools.length; i++) {
+    const workerName = confPools[i].worker_name
+    const username = minerPools[i].username
+
+    if (!username.includes(workerName)) {
+      return false
+    }
+  }
+  return true
+}
+
+function areMinerPoolsUrlsCorrectlySetup (minerPools, confPools) {
+  return confPools.every((pool, i) => minerPools[i]?.url === pool.url)
+}
+
+const DEFAULT = {}
+
+const MINER_DEFAULT = {
+  ...DEFAULT,
+  wrong_miner_pool: {
+    valid: (ctx, snap) => {
+      return isValidPoolConfigSnap(ctx, snap)
+    },
+    probe: (ctx, snap) => {
+      const configPools = ctx.thingConf.pools
+      const minerPools = snap.config.pool_config
+      return !areMinerPoolsUrlsCorrectlySetup(minerPools, configPools)
+    }
+  },
+  wrong_miner_subaccount: {
+    valid: (ctx, snap) => {
+      return isValidPoolConfigSnap(ctx, snap)
+    },
+    probe: (ctx, snap) => {
+      const configPools = ctx.thingConf.pools
+      const minerPools = snap.config.pool_config
+      if (configPools.length > 0 && minerPools.length > 0) {
+        return !isConfigWorkerNameInPoolUsername(minerPools, configPools)
+      }
+      return false
+    }
+  },
+  wrong_worker_name: {
+    valid: (ctx, snap) => {
+      return isValidPoolConfigSnap(ctx, snap)
+    },
+    probe: (ctx, snap) => {
+      const configPools = ctx.thingConf.pools
+      const minerPools = snap.config.pool_config
+      const id = ctx.id
+      const ip = snap.config.network_config.ip_address
+      if (configPools.length > 0 && minerPools.length > 0) {
+        return (
+          !isCorrectPoolUsername(id, minerPools, configPools) &&
+          !isIpPoolUsername(ip, minerPools, configPools)
+        )
+      }
+      return false
+    }
+  },
+  ip_worker_name: {
+    valid: (ctx, snap) => {
+      return isValidPoolConfigSnap(ctx, snap)
+    },
+    probe: (ctx, snap) => {
+      const configPools = ctx.thingConf.pools
+      const minerPools = snap.config.pool_config
+      const ip = snap.config.network_config.ip_address
+
+      if (configPools.length > 0 && minerPools.length > 0) {
+        return isIpPoolUsername(ip, minerPools, configPools)
+      }
+      return false
+    }
+  }
+}
+
+module.exports = {
+  specs: {
+    default: DEFAULT,
+    miner_default: MINER_DEFAULT,
+    container_default: DEFAULT,
+    powermeter_default: {}
+  }
+}