var path = require('path');
|
var crypto = require('crypto');
|
|
module.exports = {
|
createFromFile: function (filePath, useChecksum) {
|
var fname = path.basename(filePath);
|
var dir = path.dirname(filePath);
|
return this.create(fname, dir, useChecksum);
|
},
|
|
create: function (cacheId, _path, useChecksum) {
|
var fs = require('fs');
|
var flatCache = require('flat-cache');
|
var cache = flatCache.load(cacheId, _path);
|
var normalizedEntries = {};
|
|
var removeNotFoundFiles = function removeNotFoundFiles() {
|
const cachedEntries = cache.keys();
|
// remove not found entries
|
cachedEntries.forEach(function remover(fPath) {
|
try {
|
fs.statSync(fPath);
|
} catch (err) {
|
if (err.code === 'ENOENT') {
|
cache.removeKey(fPath);
|
}
|
}
|
});
|
};
|
|
removeNotFoundFiles();
|
|
return {
|
/**
|
* the flat cache storage used to persist the metadata of the `files
|
* @type {Object}
|
*/
|
cache: cache,
|
|
/**
|
* Given a buffer, calculate md5 hash of its content.
|
* @method getHash
|
* @param {Buffer} buffer buffer to calculate hash on
|
* @return {String} content hash digest
|
*/
|
getHash: function (buffer) {
|
return crypto.createHash('md5').update(buffer).digest('hex');
|
},
|
|
/**
|
* Return whether or not a file has changed since last time reconcile was called.
|
* @method hasFileChanged
|
* @param {String} file the filepath to check
|
* @return {Boolean} wheter or not the file has changed
|
*/
|
hasFileChanged: function (file) {
|
return this.getFileDescriptor(file).changed;
|
},
|
|
/**
|
* given an array of file paths it return and object with three arrays:
|
* - changedFiles: Files that changed since previous run
|
* - notChangedFiles: Files that haven't change
|
* - notFoundFiles: Files that were not found, probably deleted
|
*
|
* @param {Array} files the files to analyze and compare to the previous seen files
|
* @return {[type]} [description]
|
*/
|
analyzeFiles: function (files) {
|
var me = this;
|
files = files || [];
|
|
var res = {
|
changedFiles: [],
|
notFoundFiles: [],
|
notChangedFiles: [],
|
};
|
|
me.normalizeEntries(files).forEach(function (entry) {
|
if (entry.changed) {
|
res.changedFiles.push(entry.key);
|
return;
|
}
|
if (entry.notFound) {
|
res.notFoundFiles.push(entry.key);
|
return;
|
}
|
res.notChangedFiles.push(entry.key);
|
});
|
return res;
|
},
|
|
getFileDescriptor: function (file) {
|
var fstat;
|
|
try {
|
fstat = fs.statSync(file);
|
} catch (ex) {
|
this.removeEntry(file);
|
return { key: file, notFound: true, err: ex };
|
}
|
|
if (useChecksum) {
|
return this._getFileDescriptorUsingChecksum(file);
|
}
|
|
return this._getFileDescriptorUsingMtimeAndSize(file, fstat);
|
},
|
|
_getFileDescriptorUsingMtimeAndSize: function (file, fstat) {
|
var meta = cache.getKey(file);
|
var cacheExists = !!meta;
|
|
var cSize = fstat.size;
|
var cTime = fstat.mtime.getTime();
|
|
var isDifferentDate;
|
var isDifferentSize;
|
|
if (!meta) {
|
meta = { size: cSize, mtime: cTime };
|
} else {
|
isDifferentDate = cTime !== meta.mtime;
|
isDifferentSize = cSize !== meta.size;
|
}
|
|
var nEntry = (normalizedEntries[file] = {
|
key: file,
|
changed: !cacheExists || isDifferentDate || isDifferentSize,
|
meta: meta,
|
});
|
|
return nEntry;
|
},
|
|
_getFileDescriptorUsingChecksum: function (file) {
|
var meta = cache.getKey(file);
|
var cacheExists = !!meta;
|
|
var contentBuffer;
|
try {
|
contentBuffer = fs.readFileSync(file);
|
} catch (ex) {
|
contentBuffer = '';
|
}
|
|
var isDifferent = true;
|
var hash = this.getHash(contentBuffer);
|
|
if (!meta) {
|
meta = { hash: hash };
|
} else {
|
isDifferent = hash !== meta.hash;
|
}
|
|
var nEntry = (normalizedEntries[file] = {
|
key: file,
|
changed: !cacheExists || isDifferent,
|
meta: meta,
|
});
|
|
return nEntry;
|
},
|
|
/**
|
* Return the list o the files that changed compared
|
* against the ones stored in the cache
|
*
|
* @method getUpdated
|
* @param files {Array} the array of files to compare against the ones in the cache
|
* @returns {Array}
|
*/
|
getUpdatedFiles: function (files) {
|
var me = this;
|
files = files || [];
|
|
return me
|
.normalizeEntries(files)
|
.filter(function (entry) {
|
return entry.changed;
|
})
|
.map(function (entry) {
|
return entry.key;
|
});
|
},
|
|
/**
|
* return the list of files
|
* @method normalizeEntries
|
* @param files
|
* @returns {*}
|
*/
|
normalizeEntries: function (files) {
|
files = files || [];
|
|
var me = this;
|
var nEntries = files.map(function (file) {
|
return me.getFileDescriptor(file);
|
});
|
|
//normalizeEntries = nEntries;
|
return nEntries;
|
},
|
|
/**
|
* Remove an entry from the file-entry-cache. Useful to force the file to still be considered
|
* modified the next time the process is run
|
*
|
* @method removeEntry
|
* @param entryName
|
*/
|
removeEntry: function (entryName) {
|
delete normalizedEntries[entryName];
|
cache.removeKey(entryName);
|
},
|
|
/**
|
* Delete the cache file from the disk
|
* @method deleteCacheFile
|
*/
|
deleteCacheFile: function () {
|
cache.removeCacheFile();
|
},
|
|
/**
|
* remove the cache from the file and clear the memory cache
|
*/
|
destroy: function () {
|
normalizedEntries = {};
|
cache.destroy();
|
},
|
|
_getMetaForFileUsingCheckSum: function (cacheEntry) {
|
var contentBuffer = fs.readFileSync(cacheEntry.key);
|
var hash = this.getHash(contentBuffer);
|
var meta = Object.assign(cacheEntry.meta, { hash: hash });
|
delete meta.size;
|
delete meta.mtime;
|
return meta;
|
},
|
|
_getMetaForFileUsingMtimeAndSize: function (cacheEntry) {
|
var stat = fs.statSync(cacheEntry.key);
|
var meta = Object.assign(cacheEntry.meta, {
|
size: stat.size,
|
mtime: stat.mtime.getTime(),
|
});
|
delete meta.hash;
|
return meta;
|
},
|
|
/**
|
* Sync the files and persist them to the cache
|
* @method reconcile
|
*/
|
reconcile: function (noPrune) {
|
removeNotFoundFiles();
|
|
noPrune = typeof noPrune === 'undefined' ? true : noPrune;
|
|
var entries = normalizedEntries;
|
var keys = Object.keys(entries);
|
|
if (keys.length === 0) {
|
return;
|
}
|
|
var me = this;
|
|
keys.forEach(function (entryName) {
|
var cacheEntry = entries[entryName];
|
|
try {
|
var meta = useChecksum
|
? me._getMetaForFileUsingCheckSum(cacheEntry)
|
: me._getMetaForFileUsingMtimeAndSize(cacheEntry);
|
cache.setKey(entryName, meta);
|
} catch (err) {
|
// if the file does not exists we don't save it
|
// other errors are just thrown
|
if (err.code !== 'ENOENT') {
|
throw err;
|
}
|
}
|
});
|
|
cache.save(noPrune);
|
},
|
};
|
},
|
};
|
