session-desktop/js/modules/loki_primitives.js

/* global clearTimeout */
// was timeoutDelay
const sleepFor = ms => new Promise(resolve => setTimeout(resolve, ms));

let log
function configure(options = {}) {
  ({ log } = options);
}

// Taken from https://stackoverflow.com/questions/51160260/clean-way-to-wait-for-first-true-returned-by-promise
// The promise returned by this function will resolve true when the first promise
// in ps resolves true *or* it will resolve false when all of ps resolve false
const firstTrue = ps => {
  const newPs = ps.map(
    p =>
      new Promise(
        // eslint-disable-next-line more/no-then
        (resolve, reject) => p.then(v => v && resolve(true), reject)
      )
  );
  // eslint-disable-next-line more/no-then
  newPs.push(Promise.all(ps).then(() => false));
  return Promise.race(newPs);
};

// one action resolves all
const snodeGlobalLocks = {};
async function allowOnlyOneAtATime(name, process, timeout) {
  // if currently not in progress
  if (snodeGlobalLocks[name] === undefined) {
    // set lock
    snodeGlobalLocks[name] = new Promise(async (resolve, reject) => {
      // set up timeout feature
      let timeoutTimer = null;
      if (timeout) {
        timeoutTimer = setTimeout(() => {
          log.warn(
            `loki_snodes:::allowOnlyOneAtATime - TIMEDOUT after ${timeout}s`
          );
          delete snodeGlobalLocks[name]; // clear lock
          reject();
        }, timeout);
      }
      // do actual work
      let innerRetVal;
      try {
        innerRetVal = await process();
      } catch(e) {
        log.error(`loki_snodes:::allowOnlyOneAtATime - error ${e.code} ${e.message}`);
        throw e;
      }
      // clear timeout timer
      if (timeout) {
        if (timeoutTimer !== null) {
          clearTimeout(timeoutTimer);
          timeoutTimer = null;
        }
      }
      delete snodeGlobalLocks[name]; // clear lock
      // release the kraken
      resolve(innerRetVal);
    });
  }
  let outerRetval;
  // handle any timeouts
  try {
    outerRetval = await snodeGlobalLocks[name];
  } catch (e) {
    // we will throw for each time allowOnlyOneAtATime has been called in parallel
    log.error('loki_snodes:::allowOnlyOneAtATime - error', e.code, e.message);
    throw e;
  }
  return outerRetval;
}

function abortableIterator(array, iterator) {

  let abortIteration = false;

  // for the control promise
  let controlResolveFunctor;
  const stopPolling = new Promise(res => {
    // store resolve functor
    controlResolveFunctor = res;
  });

  // eslint-disable-next-line more/no-then
  stopPolling.then(() => {
    abortIteration = true;
  });

  const destructableList = [...array];
  const accum = [];

  return {
    start: async (serially) => {
      let item = destructableList.pop();
      while(item && !abortIteration) {
        // console.log('iterating on item', item);
        if (serially) {
          try {
            // eslint-disable-next-line no-await-in-loop
            accum.push(await iterator(item));
          } catch(e) {
            log.error(`loki_snodes:::abortableIterator - error ${e.code} ${e.message}`);
            throw e;
          }
        } else {
          accum.push(iterator(item));
        }
        item = destructableList.pop()
      }
      return accum;
    },
    stop: () => {
      /*
      log.debug('loki_snodes:::abortableIterator - Stopping',
                destructableList.length, '+', accum.length, '=', array.length,
                'aborted?', abortIteration);
      */
      controlResolveFunctor();
    },
  }
}

module.exports = {
  configure,
  sleepFor,
  allowOnlyOneAtATime,
  abortableIterator,
  firstTrue,
}