embarklabs
/
embark
mirror of https://github.com/embarklabs/embark.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

BROKEN: solc doesnt load

This commit is contained in:
Jonathan Rainville 2018-10-09 16:43:38 -04:00 committed by Pascal Precht
parent 3c0bcb18b8
commit ca3aea7923
No known key found for this signature in database
GPG Key ID: 0EE28D8D6FD85D7D
8 changed files with 222 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cmd/cmd_controller.js
View File

@ -554,6 +554,9 @@ class EmbarkController {
engine.init({}, callback);
},
function startServices(callback) {
engine.startService("processManager");
engine.startService("web3", {wait: true}); // Empty web3 as Test changes it
engine.startService("deployment");
engine.startService("testRunner");
callback();
},

3
lib/core/engine.js
View File

@ -242,7 +242,8 @@ class Engine {
this.registerModule('blockchain_connector', {
isDev: this.isDev,
web3: options.web3
web3: options.web3,
wait: options.wait
});
this.registerModule('whisper');

61
lib/modules/blockchain_connector/index.js
View File

@ -20,6 +20,7 @@ class BlockchainConnector {
this.isDev = options.isDev;
this.web3Endpoint = '';
this.isWeb3Ready = false;
this.wait = options.wait;
self.events.setCommandHandler("blockchain:web3:isReady", (cb) => {
cb(self.isWeb3Ready);
@ -34,14 +35,13 @@ class BlockchainConnector {
} else {
this.isWeb3Ready = true;
}
this.registerServiceCheck();
this.registerRequests();
this.registerWeb3Object();
this.registerEvents();
this.subscribeToPendingTransactions();
}
//initWeb3() {
initWeb3(cb) {
if (!cb) {
cb = function(){};
@ -54,22 +54,35 @@ class BlockchainConnector {
const self = this;
this.web3 = new Web3();
if (this.contractsConfig.deployment.type !== "rpc" && this.contractsConfig.deployment.type !== "ws") {
const message = __("contracts config error: unknown deployment type %s", this.contractsConfig.deployment.type);
this.logger.error(message);
// TODO find a better way
if (self.wait) {
return cb();
}
const protocol = (this.contractsConfig.deployment.type === "rpc") ? this.contractsConfig.deployment.protocol : 'ws';
let {type, host, port, accounts, protocol} = this.contractsConfig.deployment;
this.web3Endpoint = utils.buildUrl(protocol, this.contractsConfig.deployment.host, this.contractsConfig.deployment.port);//`${protocol}://${this.contractsConfig.deployment.host}:${this.contractsConfig.deployment.port}`;
if (!BlockchainConnector.ACCEPTED_TYPES.includes(type)) {
this.logger.error(__("contracts config error: unknown deployment type %s", type));
this.logger.error(__("Accepted types are: %s", BlockchainConnector.ACCEPTED_TYPES.join(', ')));
}
if (type === 'vm') {
this.provider = this._getSimulator().provider;
this.web3.setProvider(this.provider(this.contractsConfig.deployment));
return self._emitWeb3Ready();
}
protocol = (type === "rpc") ? protocol : 'ws';
this.web3Endpoint = utils.buildUrl(protocol, host, port);
const providerOptions = {
web3: this.web3,
accountsConfig: this.contractsConfig.deployment.accounts,
accountsConfig: accounts,
blockchainConfig: this.blockchainConfig,
logger: this.logger,
isDev: this.isDev,
type: this.contractsConfig.deployment.type,
type: type,
web3Endpoint: self.web3Endpoint
};
this.provider = new Provider(providerOptions);
@ -89,14 +102,36 @@ class BlockchainConnector {
})
.catch(console.error);
self.provider.fundAccounts(() => {
self.isWeb3Ready = true;
self.events.emit(WEB3_READY);
self.registerWeb3Object();
self._emitWeb3Ready();
});
});
});
}
_emitWeb3Ready() {
this.isWeb3Ready = true;
this.events.emit(WEB3_READY);
this.registerWeb3Object();
}
_getSimulator() {
try {
return require('ganache-cli');
} catch (e) {
const moreInfo = 'For more information see https://github.com/trufflesuite/ganache-cli';
if (e.code === 'MODULE_NOT_FOUND') {
this.logger.error(__('Simulator not found; Please install it with "%s"', 'npm install ganache-cli --save'));
this.logger.error(moreInfo);
throw e;
}
this.logger.error("==============");
this.logger.error(__("Tried to load Ganache CLI (testrpc), but an error occurred. This is a problem with Ganache CLI"));
this.logger.error(moreInfo);
this.logger.error("==============");
throw e;
}
}
registerEvents() {
const self = this;
self.events.on('check:wentOffline:Ethereum', () => {
@ -284,5 +319,7 @@ class BlockchainConnector {
}
}
BlockchainConnector.ACCEPTED_TYPES = ['rpc', 'ws', 'vm'];
module.exports = BlockchainConnector;

2
lib/modules/solidity/index.js
View File

@ -55,6 +55,7 @@ class Solidity {
self.logger.info(__("loading solc compiler") + "..");
self.solcW.load_compiler(function (err) {
console.log('LOADED');
self.solcAlreadyLoaded = true;
callback(err);
});
@ -146,6 +147,7 @@ class Solidity {
callback(null, compiled_object);
}
], function (err, result) {
console.log('COMPLETED COMPILATION', err);
cb(err, result);
});
}

4
lib/modules/solidity/solcP.js
View File

@ -10,6 +10,7 @@ const NpmTimer = require('../library_manager/npmTimer');
class SolcProcess extends ProcessWrapper {
constructor(options){
console.error('ALLO');
super({pingParent: false});
this._logger = options.logger;
this._showSpinner = options.showSpinner === true;
@ -66,6 +67,7 @@ class SolcProcess extends ProcessWrapper {
let solcProcess;
process.on('message', (msg) => {
console.error('MSG', msg.action);
if (msg.action === "init") {
solcProcess = new SolcProcess(msg.options);
return process.send({result: "initiated"});
@ -76,7 +78,7 @@ process.on('message', (msg) => {
return process.send({result: "loadedCompiler"});
}
else if (msg.action == 'installAndLoadCompiler') {
else if (msg.action === 'installAndLoadCompiler') {
solcProcess.installAndLoadCompiler(msg.solcVersion, msg.packagePath).then(() => {
return process.send({result: "loadedCompiler"});
});

2
lib/modules/solidity/solcW.js
View File

@ -45,6 +45,7 @@ class SolcW {
events: self.events,
silent: false
});
console.log(utils.joinPath(__dirname, 'solcP.js'));
this.solcProcess.once("result", "initiated", () => {
this.events.request("version:get:solc", function(solcVersion) {
@ -65,6 +66,7 @@ class SolcW {
self.compilerLoaded = true;
done();
});
// FIXME
this.solcProcess.send({action: "init", options: {logger: self.logger, showSpinner: !self.useDashboard}});
if (this.ipc.isServer()) {

2
lib/modules/tests/index.js
View File

@ -125,7 +125,7 @@ class TestRunner {
async.waterfall([
function setupGlobalNamespace(next) {
// TODO put default config
const test = new Test({loglevel, node: options.node, events: self.events});
const test = new Test({loglevel, node: options.node, events: self.events, logger: self.logger, config: self.embark.config});
global.embark = test;
global.assert = assert;
global.config = test.config.bind(test);

310
lib/modules/tests/test.js
View File

@ -1,7 +1,7 @@
const async = require('async');
const Engine = require('../../core/engine.js');
const TestLogger = require('./test_logger.js');
const Web3 = require('web3');
// const Engine = require('../../core/engine.js');
// const TestLogger = require('./test_logger.js');
// const Web3 = require('web3');
const AccountParser = require('../../utils/accountParser');
// TODO: breaks module isolation; tests need to be refactored to use the engine and avoid this
const Provider = require('../blockchain_connector/provider.js');
@ -9,157 +9,43 @@ const utils = require('../../utils/utils');
const EmbarkJS = require('embarkjs');
function getSimulator() {
try {
return require('ganache-cli');
} catch (e) {
const moreInfo = 'For more information see https://github.com/trufflesuite/ganache-cli';
if (e.code === 'MODULE_NOT_FOUND') {
console.error(__('Simulator not found; Please install it with "%s"', 'npm install ganache-cli --save'));
console.error(moreInfo);
throw e;
}
console.error("==============");
console.error(__("Tried to load Ganache CLI (testrpc), but an error occurred. This is a problem with Ganache CLI"));
console.error(moreInfo);
console.error("==============");
throw e;
}
}
class Test {
constructor(options) {
this.options = options || {};
this.simOptions = {};
this.events = options.events;
this.logger = options.logger;
this.configObj = options.config;
this.ready = true;
this.firstRunConfig = true;
this.error = false;
this.contracts = {};
this.firstDeployment = true;
this.needConfig = true;
this.web3 = new Web3();
this.engine = new Engine({
this.web3 = null;
this.blockchainConnector = null;
this.provider = null;
this.accounts = [];
/*this.engine = new Engine({
env: this.options.env || 'test',
// TODO: config will need to detect if this is a obj
embarkConfig: this.options.embarkConfig || 'embark.json',
interceptLogs: false
});
}
initWeb3Provider(callback) {
const self = this;
if (this.provider) {
this.provider.stop();
}
if (this.simOptions.accounts) {
this.simOptions.accounts = this.simOptions.accounts.map((account) => {
if (!account.hexBalance) {
account.hexBalance = '0x8AC7230489E80000'; // 10 ether
}
return {balance: account.hexBalance, secretKey: account.privateKey};
});
}
if (this.simOptions.host || (this.options.node && this.options.node !== 'vm')) {
let options = this.simOptions;
if (this.options.node) {
options = utils.deconstructUrl(this.options.node);
}
let {host, port, type, protocol, accounts} = options;
if (!protocol) {
protocol = (options.type === "rpc") ? 'http' : 'ws';
}
const endpoint = `${protocol}://${host}:${port}`;
const providerOptions = {
web3: this.web3,
type,
accountsConfig: accounts,
blockchainConfig: this.engine.config.blockchainConfig,
logger: this.engine.logger,
isDev: false,
web3Endpoint: endpoint
};
console.info(`Connecting to node at ${endpoint}`.cyan);
return utils.pingEndpoint(host, port, type, protocol, this.engine.config.blockchainConfig.wsOrigins.split(',')[0], (err) => {
if (err) {
console.error(`Error connecting to the node, there might be an error in ${endpoint}`.red);
return callback(err);
}
self.provider = new Provider(providerOptions);
return self.provider.startWeb3Provider((err) => {
if (err) {
return callback(err);
}
callback();
});
});
}
if (!this.sim) {
this.sim = getSimulator();
}
let simProvider = this.sim.provider(this.simOptions);
if (this.options.coverage) {
// Here we patch the sendAsync method on the provider. The goal behind this is to force pure/constant/view calls to become
// transactions, so that we can pull in execution traces and account for those executions in code coverage.
//
// Instead of a simple call, here's what happens:
//
// 1) A transaction is sent with the same payload, and a pre-defined gas price;
// 2) We wait for the transaction to be mined by asking for the receipt;
// 3) Once we get the receipt back, we dispatch the real call and pass the original callback;
//
// This will still allow tests to get the return value from the call and run contracts unmodified.
simProvider.realSendAsync = simProvider.sendAsync.bind(simProvider);
simProvider.sendAsync = function(payload, cb) {
if(payload.method !== 'eth_call') {
return simProvider.realSendAsync(payload, cb);
}
self.engine.events.request('reporter:toggleGasListener');
let newParams = Object.assign({}, payload.params[0], {gasPrice: '0x77359400'});
let newPayload = {
id: payload.id + 1,
method: 'eth_sendTransaction',
params: [newParams],
jsonrpc: payload.jsonrpc
};
simProvider.realSendAsync(newPayload, (_err, response) => {
let txHash = response.result;
self.web3.eth.getTransactionReceipt(txHash, (_err, _res) => {
self.engine.events.request('reporter:toggleGasListener');
simProvider.realSendAsync(payload, cb);
});
});
};
}
this.web3.setProvider(simProvider);
callback();
}
initDeployServices() {
this.engine.startService("web3", {
web3: this.web3
});
this.engine.startService("deployment", {
trackContracts: false,
compileOnceOnly: true,
disableOptimizations: this.options.coverage
});
this.gasLimit = 6000000;
this.engine.events.request('deploy:setGasLimit', this.gasLimit);
});*/
}
init(callback) {
let self = this;
this.showNodeHttpWarning();
this.events.request('blockchain:object', (connector) => {
this.blockchainConnector = connector;
// TODO use events instead of using web3 directly?
this.web3 = this.blockchainConnector.web3;
callback();
});
/*let self = this;
async.waterfall([
function initEngine(cb) {
self.engine.init({
@ -190,10 +76,132 @@ class Test {
self.showNodeHttpWarning();
cb();
}
], callback);
], callback);*/
}
connectToIpcNode(cb) {
initWeb3Provider(callback) {
const self = this;
if (this.provider) {
this.provider.stop();
}
if (this.simOptions.accounts) {
this.simOptions.accounts = this.simOptions.accounts.map((account) => {
if (!account.hexBalance) {
account.hexBalance = '0x8AC7230489E80000'; // 10 ether
}
return {balance: account.hexBalance, secretKey: account.privateKey};
});
}
// TODO use event for this
if (!this.simOptions.host || (this.options.node && this.options.node === 'vm')) {
this.simOptions.type = 'vm';
}
this.configObj.contractsConfig.deployment = this.simOptions;
this.blockchainConnector.contractsConfig = this.configObj.contractsConfig;
this.blockchainConnector.isWeb3Ready = false;
// TODO change this
if (this.simOptions.host || (this.options.node && this.options.node !== 'vm')) {
let options = this.simOptions;
if (this.options.node) {
options = utils.deconstructUrl(this.options.node);
}
let {host, port, type, protocol, accounts} = options;
if (!protocol) {
protocol = (options.type === "rpc") ? 'http' : 'ws';
}
const endpoint = `${protocol}://${host}:${port}`;
const providerOptions = {
web3: this.web3,
type,
accountsConfig: accounts,
blockchainConfig: this.configObj.blockchainConfig,
logger: this.logger,
isDev: false,
web3Endpoint: endpoint
};
console.info(`Connecting to node at ${endpoint}`.cyan);
return utils.pingEndpoint(host, port, type, protocol, this.configObj.blockchainConfig.wsOrigins.split(',')[0], (err) => {
if (err) {
console.error(`Error connecting to the node, there might be an error in ${endpoint}`.red);
return callback(err);
}
self.provider = new Provider(providerOptions);
return self.provider.startWeb3Provider((err) => {
if (err) {
return callback(err);
}
callback();
});
});
}
// if (!this.sim) {
// this.sim = getSimulator();
// }
// let simProvider = this.sim.provider(this.simOptions);
// TODO change this
/*if (this.options.coverage) {
// Here we patch the sendAsync method on the provider. The goal behind this is to force pure/constant/view calls to become
// transactions, so that we can pull in execution traces and account for those executions in code coverage.
//
// Instead of a simple call, here's what happens:
//
// 1) A transaction is sent with the same payload, and a pre-defined gas price;
// 2) We wait for the transaction to be mined by asking for the receipt;
// 3) Once we get the receipt back, we dispatch the real call and pass the original callback;
//
// This will still allow tests to get the return value from the call and run contracts unmodified.
simProvider.realSendAsync = simProvider.sendAsync.bind(simProvider);
simProvider.sendAsync = function(payload, cb) {
if(payload.method !== 'eth_call') {
return simProvider.realSendAsync(payload, cb);
}
self.events.request('reporter:toggleGasListener');
let newParams = Object.assign({}, payload.params[0], {gasPrice: '0x77359400'});
let newPayload = {
id: payload.id + 1,
method: 'eth_sendTransaction',
params: [newParams],
jsonrpc: payload.jsonrpc
};
simProvider.realSendAsync(newPayload, (_err, response) => {
let txHash = response.result;
self.web3.eth.getTransactionReceipt(txHash, (_err, _res) => {
self.events.request('reporter:toggleGasListener');
simProvider.realSendAsync(payload, cb);
});
});
};
}*/
this.blockchainConnector.initWeb3(callback);
// this.web3.setProvider(simProvider);
// callback();
}
/*initDeployServices() {
this.engine.startService("web3", {
web3: this.web3
});
this.engine.startService("deployment", {
trackContracts: false,
compileOnceOnly: true,
disableOptimizations: this.options.coverage
});
this.gasLimit = 6000000;
this.engine.events.request('deploy:setGasLimit', this.gasLimit);
}*/
/*connectToIpcNode(cb) {
this.engine.ipc.request('blockchain:node', {}, (err, node) => {
if (err) {
this.engine.logger.error(err.message || err);
@ -203,11 +211,11 @@ class Test {
this.showNodeHttpWarning();
cb();
});
}
}*/
showNodeHttpWarning() {
if (this.options.node.startsWith('http')) {
this.engine.logger.warn("You are using http to connect to the node, as a result the gas details won't be correct." +
this.logger.warn("You are using http to connect to the node, as a result the gas details won't be correct." +
" For correct gas details reporting, please use a websockets connection to your node.");
}
}
@ -252,7 +260,7 @@ class Test {
if (accounts) {
self.simOptions.accounts = AccountParser.parseAccountsConfig(accounts, self.web3);
} else {
self.simOptions.account = null;
self.simOptions.accounts = null;
}
Object.assign(self.simOptions, {
@ -270,7 +278,7 @@ class Test {
return callback(err);
}
self.firstRunConfig = false;
self.initDeployServices();
// self.initDeployServices();
callback();
});
}
@ -299,14 +307,14 @@ class Test {
if (!self.firstDeployment) {
return next();
}
console.info('Compiling contracts'.cyan);
self.engine.events.request("contracts:build", false, (err) => {
self.logger.info('Compiling contracts'.cyan);
self.events.request("contracts:build", false, (err) => {
self.firstDeployment = false;
next(err);
});
},
function resetContracts(next) {
self.engine.events.request("contracts:reset:dependencies", next);
self.events.request("contracts:reset:dependencies", next);
},
function deploy(next) {
self._deploy(options, (err, accounts) => {
@ -323,6 +331,7 @@ class Test {
}
], (err, accounts) => {
if (err) {
// TODO Do not exit in case of not a normal run (eg after a change)
process.exit(1);
}
callback(null, accounts);
@ -333,7 +342,8 @@ class Test {
const self = this;
async.waterfall([
function getConfig(next) {
self.engine.config.contractsConfig = {contracts: config.contracts, versions: self.versions_default};
// TODO use events instead of modifying directly
self.configObj.contractsConfig = {contracts: config.contracts, versions: self.versions_default};
next();
},
function getAccounts(next) {
@ -349,7 +359,7 @@ class Test {
function getBalance(accounts, next) {
self.web3.eth.getBalance(self.web3.eth.defaultAccount).then((balance) => {
if (parseInt(balance, 10) === 0) {
console.warn("Warning: default account has no funds");
self.logger.warn("Warning: default account has no funds");
}
next(null, accounts);
}).catch((err) => {
@ -357,12 +367,12 @@ class Test {
});
},
function deploy(accounts, next) {
self.engine.events.request('deploy:contracts:test', () => {
self.events.request('deploy:contracts:test', () => {
next(null, accounts);
});
},
function createContractObject(accounts, next) {
self.engine.events.request('contracts:all', (err, contracts) => {
self.events.request('contracts:all', (err, contracts) => {
async.each(contracts, (contract, eachCb) => {
if (!self.contracts[contract.className]) {
@ -397,7 +407,7 @@ class Test {
}
], function (err, accounts) {
if (err) {
console.log(__('terminating due to error'));
self.logger.log(__('terminating due to error'));
return callback(err);
}
callback(null, accounts);