Saving the cache

[node-cache]

Saving the cache

[erdii]

@AnandChowdhary Fraud looks like a nice project! Glad to see that you built something useful for you business on nodecache!

[smrchy]

Nice idea for a new project that implements nodecache and does just this.

[mpneuried]

I'm developing a solution for this requirement during my time in the train.

Have a look: https://github.com/mpneuried/node-cache-persist
It's not published yet, because the documentation is missing and the api is not fixed yet.

[cinder92]

and where is saving cache this project now?

[supukarmin]

Had the same problem, just wrote some short functions; no need for a library, the combination of .keys and .mget creates the magic:

const NodeCache = require('node-cache');
const fs = require('fs');
const path = require('path');

const cache = new NodeCache();

const saveCache = (cache, directoryPath = __dirname) => {
    cache.keys((err, keys) => {
      if (!err) {
        cache.mget(keys, (err, cacheData) => {
          if (!err) {
            const stringifiedData = JSON.stringify(cacheData);
            fs.writeFileSync(path.join(directoryPath, 'cache.json'), stringifiedData)
          } else {
            console.error(err);
          }
        });
      } else {
        console.error(err);
      }
    });
}

const loadCache = (cache, directoryPath = __dirname) => {
  const filePath = path.join(directoryPath, 'cache.json');
  if (fs.existsSync(filePath)) {
    const jsonData = fs.readFileSync(filePath, 'utf8');
    const data = JSON.parse(jsonData);
    for (const [key, val] of Object.entries(data)) {
      if (data.hasOwnProperty(key)) {
        cache.set(key, val);
      }
    }
  }
};

loadCache(cache);

//and then put it into an interval or save it after every change or whatever suits your needs

setInterval(() => {
  saveCache(cache);
}, 60*1000);

[erdii]

@supukarmin: fs.writeFileSync(path.join(directoryPath, 'cache.json'), stringifiedData)

This will block your proccess while saving. I think you are better off with fs.writeFile

Actually all fs.*Sync functions you use, have counterparts without the Sync-suffix, that will not block your process and use the callblack-pattern for the flow of your node-app.

[erdii]

@supukarmin It DOES ALWAYS block your process.
Read more about it here: https://nodejs.org/en/docs/guides/blocking-vs-non-blocking/

Edit: small example to demonstrate:

function blockEverything() {
	console.log("now the process will be blocked forever");
	while(true) {}
}

setInterval(() => {
	console.log("not-blocked");
}, 500)

setTimeout(blockEverything, 2500);

Edit: it seems that @supukarmin deleted a comment here... 😞

[AnandChowdhary]

I made a library which uses a file system-based key-JSON storage, based on nodecache. It's kind of the opposite of "save the cache", since the primary source is the file system, but every key which is fetched is then saved in the cache. If you're still interested in having a file system store for your cache, check it out: https://github.com/AnandChowdhary/fraud/.

[erdii]

Closed because the filesystem is out of scope (at least for now)