.then(f => {
const recs = f.split('\n')
const parse = _.flow([safeJsonParse, massage])
const txs = _.remove(_.isEmpty, _.map(parse, recs))
_.forEach(tx => { txTable[tx.id] = tx }, txs)
return _.sortBy(tx => tx.deviceTime, _.values(txTable))
})
function processCryptos (codes) {
if (_.isEmpty(codes)) {
logger.info('No cryptos selected. Exiting.')
process.exit(0)
}
logger.info('Thanks! Installing: %s. Will take a while...', _.join(', ', codes))
const goodVolume = doVolume.prepareVolume()
if (!goodVolume) {
logger.error('There was an error preparing the disk volume. Exiting.')
process.exit(1)
}
const selectedCryptos = _.map(code => _.find(['code', code], cryptos), codes)
_.forEach(setupCrypto, selectedCryptos)
common.es('sudo service supervisor restart')
const blockchainDir = coinUtils.blockchainDir()
const backupDir = path.resolve(os.homedir(), 'backups')
const rsyncCmd = `( \
(crontab -l 2>/dev/null || echo -n "") | grep -v "@daily rsync ".*"wallet.dat"; \
echo "@daily rsync -r --prune-empty-dirs --include='*/' \
--include='wallet.dat' \
--exclude='*' ${blockchainDir} ${backupDir} > /dev/null" \
) | crontab -`
common.es(rsyncCmd)
logger.info('Installation complete.')
}
module.exports = function setupLogger(methods, verbose, defaults) {
_.flow(
_.defaults(defaults || printers),
_.omit(verbose || ['debug']),
_.toPairs,
_.forEach(printer => logger.on(printer[0], printer[1]))
)(methods);
};
const checkCircularDependencies = (graphDetails) => {
const circularDependencies = graphDetails.circular().getArray();
if (circularDependencies.length) {
f.forEach(modules => {
if (modules.length === 1) {
console.log(`found self dependency in module "${modules[0]}"`);
} else {
console.log(`found circular dependencies between modules "${modules.join(', ')}"`);
}
})(circularDependencies);
throw new Error('circular dependencies');
}
};
return next => (action) => {
const previousState: State = getState();
const returnValue = next(action);
const nextState: State = getState();
if (!isEqual(nextState.customUnits, previousState.customUnits)) {
batchImplementation.setCustomUnits(nextState.customUnits);
}
const { added, changed, removed } = getAddedChangedRemovedSectionItems(
nextState.sectionTextInputs,
previousState.sectionTextInputs
);
forEach(batchImplementation.unloadSection, removed);
const sectionsToLoad = concat(added, changed);
forEach(sectionId => (
batchImplementation.loadSection(sectionId, nextState.sectionTextInputs[sectionId])
), sectionsToLoad);
return returnValue;
};
const checkMissingDependencies = (moduleDefinitions, existingModules, dependencyGraph) => {
const missingDependencies = f.flow(
f.mapValues(
f.reject(dependencyName =>
moduleDefinitions[dependencyName] || existingModules[dependencyName]
)
),
f.pickBy('length'),
f.toPairs
)(dependencyGraph);
if (missingDependencies.length) {
f.forEach(([name, missing]) => {
console.log(`unable to find dependencies "${missing.join(', ')}" for module "${name}"`);
})(missingDependencies);
throw new Error('missing dependencies');
}
};
setCustomUnits: (units) => {
customUnits = units;
const previousSectionIds = keys(previousResultsPerSection);
const previousInputsPerSection = mapValues(map('input'), previousResultsPerSection);
forEach(sectionId => {
clearCacheFor(sectionId);
if (!queuedInputs[sectionId]) {
queuedInputs[sectionId] = previousInputsPerSection[sectionId];
}
}, previousSectionIds);
if (fiber) fiber.cancel();
fiber = null;
queueComputation();
},
const checkVoidModules = (createdModules, graphDetails) => {
const voidModulesInjected = f.flow(
f.pickBy(module => module == null),
f.keys,
f.tap(modules => {
if (modules.length) {
console.log(`the modules "${modules.join(', ')}" are void`);
}
}),
f.map(moduleName => [moduleName, graphDetails.depends(moduleName)]),
f.filter('1.length')
)(createdModules);
if (voidModulesInjected.length) {
f.flow(
f.forEach(([moduleName, dependents]) => {
console.log(`the module "${moduleName}" has no return and can't\
be injected in the modules "${dependents.join(', ')}"`);
})
)(voidModulesInjected);
throw new Error('depending on void modules');
}
};
const sectionComputation = (state: CalculationState, next) => {
const { sectionId, forceRecalculation, constants, instance, inputs } = state;
let { previousResults, results } = state;
const getCurrentState = (): CalculationState =>
({ sectionId, forceRecalculation, instance, constants, inputs, previousResults, results });
const remainingInputs = inputs.slice(results.length);
let didPerformExpensiveComputation = false;
for (const input of remainingInputs) {
const previousEntryIndex = findIndex({ input }, previousResults);
let result;
if (previousEntryIndex !== -1) {
// Almost free, do even if we've exceeded the frame budget
const previousValue = previousResults[previousEntryIndex];
result = previousValue.removedAssignment || previousValue.result;
previousResults = pullAt(previousEntryIndex, previousResults);
} else if (!didPerformExpensiveComputation) {
// Expensive, don't do if we've exceeded the frame budget
result = instance.parse(input);
didPerformExpensiveComputation = true;
} else {
next(getCurrentState());
return;
}
results = concat(results, { input, result, removedAssignment: null });
}
results = removeDuplicateAssignments(results);
const newChangedAssignments = getNewChangedAssignments(constants, results);
const removedAssignments = getAssignments(previousResults);
if (!isEmpty(newChangedAssignments) || !isEmpty(removedAssignments)) {
const nextConstants = getNextConstants(constants, newChangedAssignments, removedAssignments);
next(getStateForRecalculation(getCurrentState(), nextConstants));
return;
}
const entries = map('result', results);
// FIXME: Try to not use internal API
const total = flow(
map('value'),
compact,
filter(value => includes(value.type, typesToSkipInTotal)),
([head, ...tail]) => reduce((left, right) => ({
type: 'NODE_FUNCTION',
name: 'add',
args: [left, right],
}), head, tail),
totalAst => instance.resolver.resolve(totalAst),
value => ({
text: '',
value,
pretty: value ? instance.formatter.format(instance.resolverContext, value) : '',
tokens: [],
})
)(entries);
forEach(resultListener => resultListener(sectionId, entries, total), resultListeners);
delete queuedInputs[sectionId];
previousResultsPerSection[sectionId] = results;
constantsPerSection[sectionId] = constants;
instancesPerSection[sectionId] = instance;
fiber = null;
queueComputation();
};
function registerTrades (pi, newBills) {
_.forEach(bill => pi.buy(bill), newBills)
}