utils.js

'use strict';

const { writeFile } = require('node:fs/promises');

let CACHE_HEARTBEAT_INTERVAL;
let CACHE_HEARTBEAT_OFFSET;

const nop = () => { };

function createReadyPromise() {
  let resolvePromise, promise = new Promise((resolve) => { resolvePromise = resolve; });
  return [promise, resolvePromise];
}

const cacheMap = new class extends Map {
  get(symbol) {
    let entry = super.get(symbol);
    if (!entry) {
      entry = {
        readLock: Promise.resolve(),
        writeLocks: new Set(),
      };
      this.set(symbol, entry);
    }
    return entry;
  }
}

// multiple writers
async function aquireCacheWriteLock(key) {
  const { readLock, writeLocks } = cacheMap.get(key);
  const [lock, releaseLock] = createReadyPromise();
  await readLock;
  writeLocks.add(lock);
  return function releaseCacheWriteLock() {
    writeLocks.delete(lock);
    releaseLock();
  }
}

// one reader
async function aquireCacheReadLock(key) {
  const { readLock, writeLocks } = cacheMap.get(key);
  const [lock, releaseLock] = createReadyPromise();
  await readLock;
  cacheMap.set(key, { readLock: lock, writeLocks });
  await Promise.all(writeLocks);
  return function releaseCacheReadLock() {
    releaseLock();
  }
}

class CounterMap extends Map {
  get(key) {
    return super.get(key) ?? (super.set(key, 0), 0);
  }
  inc(key, value = 1) {
    this.set(key, this.get(key) + value);
  }
}

function convertObjectToPrometheusLabels(object) {
  // do not verify, prometheus will blame
  return '{' + Object.entries(object).map(([key, value]) => (key + '="' + value + '"')).join(',') + '}';
}

function scheduleHeartbeat(heartbeatFilePath) {
  // Touch the heartbeat file at multiples of the interval, so we can assume
  // that something went wrong if many disconnecst are at interval bounday.
  // The offset is added because the mtime reported by stat is som msecs behind
  // the scheduled heartbeat.
  const timeout = CACHE_HEARTBEAT_INTERVAL + CACHE_HEARTBEAT_OFFSET - (
    Date.now() % CACHE_HEARTBEAT_INTERVAL
  );
  async function heartbeat() {
    await writeFile(heartbeatFilePath, '');
    scheduleHeartbeat(heartbeatFilePath);
  }
  setTimeout(heartbeat, timeout);
}

module.exports = function (options) {
  ({
    CACHE_HEARTBEAT_INTERVAL,
    CACHE_HEARTBEAT_OFFSET,
  } = options);
  return {
    nop,
    createReadyPromise,
    aquireCacheWriteLock,
    aquireCacheReadLock,
    CounterMap,
    convertObjectToPrometheusLabels,
    startHeartbeat: scheduleHeartbeat,
  }
};