@nxtedition/lib 27.0.3 → 27.0.4

package/app.js

@@ -562,7 +562,7 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
 
   if (process.platform === 'linux' && appConfig.numa != null && appConfig.numa !== '') {
     let numa = appConfig.numa
-    if (numa == 'auto' || numa === true) {
+    if (numa == 'auto' || numa === true || numa === 'hash') {
       numa = hashString(
         JSON.stringify({ serviceName, serviceModule, serviceInstanceId, serviceWorkerId }),
       )
@@ -577,33 +577,27 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
           .observe(`${config.hostname}:monitor.stats?`, ds.record.PROVIDER)
           .pipe(
             rxjs.map((stats) => stats?.net?.bonding?.[0]?.numaNode ?? null),
-            rxjs.filter((n) => Number.isInteger(n) && n >= 0),
-            rxjs.timeout({
-              first: 10e3,
-              with: () => rxjs.of(null),
-            }),
             rxjs.distinctUntilChanged(),
             rxjs.retry({
-              resetOnSuccess: true,
               delay(err, retryCount) {
                 logger.error({ err, retryCount }, 'net numa failed')
                 return rxjs.timer(10e3)
               },
             }),
           )
-          .subscribe((numaNode) => {
-            if (numaNode != null) {
+          .subscribe((numa) => {
+            if (numa != null) {
               try {
-                const affinity = numa.setAffinity(numaNode)
+                const affinity = numa.setAffinity(numa)
                 logger.debug(
-                  { hostname: config.hostname, numaNode, affinity },
+                  { hostname: config.hostname, numa, affinity },
                   'net numa succeeded',
                 )
               } catch (err) {
-                logger.error({ err, hostname: config.hostname, numaNode }, 'net numa failed')
+                logger.error({ err, hostname: config.hostname, numa }, 'net numa failed')
               }
             } else {
-              logger.warn({ hostname: config.hostname, numaNode }, 'net numa missing')
+              logger.warn({ hostname: config.hostname, numa }, 'net numa missing')
             }
           })
       }

package/numa.js

@@ -5,66 +5,100 @@ import { sched_setaffinity } from '@nxtedition/sched'
 
 function parseRange(value) {
   if (typeof value !== 'string') {
-    throw new Error('CPU range must be a string')
+    throw new Error('range must be a string')
   }
 
   const range = []
   for (const part of value.split(',')) {
-    if (part.includes('-')) {
-      const [start, end, ...rest] = part.split('-').map(Number)
+    const trimmed = part.trim()
+    if (!trimmed) {
+      continue
+    }
+
+    if (trimmed.includes('-')) {
+      const [startStr, endStr, ...rest] = trimmed.split('-')
+
       if (rest.length > 0) {
-        throw new Error('Invalid CPU range')
+        throw new Error(`Invalid range: "${trimmed}"`)
+      }
+
+      const start = Number(startStr)
+      const end = Number(endStr)
+
+      if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < 0) {
+        throw new Error(`Invalid number in range: "${trimmed}"`)
       }
+
+      if (end < start) {
+        throw new Error(`Invalid range order: "${trimmed}" (end < start)`)
+      }
+
       for (let i = start; i <= end; i++) {
         range.push(i)
       }
-    } else if (part) {
-      range.push(Number(part))
+    } else {
+      const num = Number(trimmed)
+      if (!Number.isInteger(num) || num < 0) {
+        throw new Error(`Invalid number: "${trimmed}"`)
+      }
+      range.push(num)
     }
   }
-  if (range.some((x) => !Number.isInteger(x) || x < 0)) {
-    throw new Error('Invalid CPU range')
-  }
-  return range
+
+  return [...new Set(range)].sort((a, b) => a - b)
 }
 
 /**
  *
- * @param {number|number[]} numa
+ * @param {null|number|number[]} numa
  * @returns {number[]}
  */
 export function setAffinity(numa) {
-  const indices = Array.from(new Set([numa].flat()))
-  if (indices.some((x) => !Number.isInteger(x) || x < 0)) {
-    throw new Error('NUMA node must be a non-negative integer')
-  }
+  let affinity
 
-  const isolated = parseRange(fs.readFileSync('/sys/devices/system/cpu/isolated', 'utf8').trim())
+  if (numa === null) {
+    affinity = parseRange(fs.readFileSync('/sys/devices/system/cpu/present', 'utf8').trim())
+  } else {
+    if (numa.some((x) => !Number.isInteger(x) || x < 0)) {
+      throw new Error(
+        'NUMA node must be null, a non-negative integer or array of non-negative integers',
+      )
+    }
 
-  const allNodes = []
-  for (const entry of fs.readdirSync('/sys/devices/system/node')) {
-    if (!entry.startsWith('node')) {
-      continue
+    const allNodes = []
+    for (const entry of fs.readdirSync('/sys/devices/system/node')) {
+      if (!/^node\d+$/.test(entry)) {
+        continue
+      }
+
+      const cpulist = fs
+        .readFileSync(path.join('/sys/devices/system/node', entry, 'cpulist'), 'utf8')
+        .trim()
+
+      allNodes.push(parseRange(cpulist))
     }
 
-    const cpulist = fs
-      .readFileSync(path.join('/sys/devices/system/node', entry, 'cpulist'), 'utf8')
-      .trim()
+    if (allNodes.length === 0) {
+      throw new Error('No NUMA nodes found')
+    }
 
-    allNodes.push(parseRange(cpulist))
+    affinity = numa.flatMap((i) => allNodes[i % allNodes.length] ?? [])
   }
 
-  if (allNodes.length === 0) {
-    throw new Error('No NUMA nodes found')
+  const isolated = parseRange(fs.readFileSync('/sys/devices/system/cpu/isolated', 'utf8').trim())
+
+  affinity = affinity.filter((cpu) => !isolated.includes(cpu))
+  affinity = [...new Set(affinity)].sort((a, b) => a - b)
+
+  if (affinity.length === 0) {
+    throw new Error('Resulting CPU affinity is empty')
   }
 
-  const affinity = indices
-    .flatMap((i) => allNodes[i % allNodes.length] ?? [])
-    .filter((cpu) => !isolated.includes(cpu))
   sched_setaffinity(0, affinity)
+
   globalThis.__nxt_sched_affinity = {
     cpulist: affinity,
-    nodelist: indices,
   }
+
   return affinity
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "27.0.3",
+  "version": "27.0.4",
   "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -52,8 +52,8 @@
     "@elastic/transport": "^8.9.3",
     "@nxtedition/nxt-undici": "^6.4.17",
     "@nxtedition/sched": "^1.0.2",
-    "@nxtedition/template": "^1.0.0-alpha.0",
-    "@nxtedition/weak-cache": "^1.0.0-alpha.0",
+    "@nxtedition/template": "^1.0.0",
+    "@nxtedition/weak-cache": "^1.0.0",
     "diff": "5.2.0",
     "fast-querystring": "^1.1.2",
     "http-errors": "^2.0.0",
@@ -87,5 +87,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "383b7fe1d10a8b7d80aa80ea81e7828f415d248d"
+  "gitHead": "be0475e7b0d724ba6f2f9fdbaa0c3f069e49e6a7"
 }

package/time.js

@@ -10,19 +10,9 @@ export function fastNow() {
   return fastNowTime
 }
 
-export function isTimeBetween(date, startTime, endTime, isUTC) {
-  let currentHours = date.getHours()
-  let currentMinutes = date.getMinutes()
-
-  if (isUTC) {
-    currentHours = date.getUTCHours()
-    currentMinutes = date.getUTCMinutes()
-  } else {
-    // Convert local time to UTC equivalent
-    const utcDate = new Date(date.getTime() + date.getTimezoneOffset() * 60000)
-    currentHours = utcDate.getUTCHours()
-    currentMinutes = utcDate.getUTCMinutes()
-  }
+export function isTimeBetween(date, startTime, endTime) {
+  const currentHours = date.getHours()
+  const currentMinutes = date.getMinutes()
 
   // Validate and parse start and end times
   if (!startTime) startTime = '00:00' // Default start at midnight