@testim/testim-cli/commons/runnerFileCache.js

"use strict";

const path = require('path');
const Promise = require('bluebird');
const debounce = require('lodash/debounce');
const fs = Promise.promisifyAll(require('fs'));
const { getCliLocation } = require('../utils');

const cliLocation = getCliLocation();
const CACHE_LOCATION = path.resolve(cliLocation, 'testim-cache', 'testim.cache')

const logger = require('./logger').getLogger('local cache');
const crypto = require('crypto');

let encryptKeyResolve;
let _encryptKeyPromise = new Promise(resolve => encryptKeyResolve = resolve);

const THREE_HOURS = 1000 * 60 * 60 * 3;

const localRunnerCache = fs.readFileAsync(CACHE_LOCATION).then(async buffer => {
    const key = await _encryptKeyPromise;
    return decrypt(key, buffer);
}).timeout(30000).catch(() => ({}));

const encryptAndSave = debounce(async function encryptAndSave(object) {
    const key = await _encryptKeyPromise;
    const iv = crypto.randomBytes(16);
    const objStr = JSON.stringify(object);
    const keyBuffer = Buffer.from(key);
    let cipher = crypto.createCipheriv('aes-256-cbc', Buffer.concat([keyBuffer, Buffer.alloc(32)], 32), iv);
    let result = Buffer.concat([iv, cipher.update(objStr), cipher.final()]);
    fs.writeFileAsync(CACHE_LOCATION, result).catch((err) => {
        logger.error('failed saving cache', {err});
    });
}, 200);

function decrypt(key, buffer) {
    const iv = buffer.slice(0, 16);
    const encryptedText = buffer.slice(16);
    const keyBuffer = Buffer.from(key);
    let decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.concat([keyBuffer, Buffer.alloc(32)], 32), iv);
    let decrypted = decipher.update(encryptedText);
    return JSON.parse(Buffer.concat([decrypted, decipher.final()]));
}
// argument less memoize for functions with a global cache name
function memoize(fn, fnName, duration = THREE_HOURS, parameters = undefined) {
    return Promise.method(async function memoized() {
        if (parameters) {
            fnName = fnName + JSON.stringify(parameters);
        }
        const cached = await get(fnName);
        if (cached) {
            logger.debug("cache hit:", { fnName });
            return cached;
        }
        logger.debug("cache miss:", { fnName });
        const value = await fn();
        if (value) {
            await set(fnName, value, duration);
        }
        return value;
    });
}
async function get(key) {
    const obj = await localRunnerCache;
    const valueExpiry = obj[key];
    if (!valueExpiry) {
        return undefined; // not in cache
    }
    const { value, expiry } = valueExpiry;
    if (expiry < Date.now()) {
        return undefined;
    }
    if (!value) {
        return undefined;
    }
    return value;
};

async function set(key, value, ttl) {
    try {
        const obj = await localRunnerCache;
        obj[key] = { value, expiry: Date.now() + ttl };
        encryptAndSave(obj);
    } catch (e) {
        logger.error('failed updating cache');
    }
};

module.exports.setEncryptKey = encryptKeyResolve;
module.exports.memoize = memoize;
module.exports.get = get;

module.exports.set = set;