Added swarm support in embarkjs, isAvailable for messages/storage, swarm/ipfs checks

js/embark.js

@@ -182,9 +182,7 @@ EmbarkJS.Contract.prototype.send = function(value, unit, _options) {
 
 EmbarkJS.Storage = {};
 
-EmbarkJS.Storage.Providers = {
-    SWARM: 'swarm'
-};
+EmbarkJS.Storage.Providers = {};
 
 EmbarkJS.Storage.saveText = function(text) {
   if (!this.currentStorage) {
@@ -230,6 +228,10 @@ EmbarkJS.Storage.setProvider = function(provider, options) {
   return providerObj.setProvider(options);
 };
 
+EmbarkJS.Storage.isAvailable = function(){
+  return this.currentStorage.isAvailable();
+};
+
 EmbarkJS.Messages = {};
 
 EmbarkJS.Messages.Providers = {};
@@ -250,6 +252,10 @@ EmbarkJS.Messages.setProvider = function(provider, options) {
   return providerObj.setProvider(options);
 };
 
+EmbarkJS.Messages.isAvailable = function(){
+  return this.currentMessages.isAvailable();
+};
+
 EmbarkJS.Messages.sendMessage = function(options) {
   if (!this.currentMessages) {
     throw new Error('Messages provider not set; e.g EmbarkJS.Messages.setProvider("whisper")');

js/embarkjs/orbit.js

@@ -85,3 +85,11 @@ EmbarkJS.Messages.Orbit.listenTo = function(options) {
     return promise;
 };
 
+// TODO: needs a real check for availability
+// TODO: not tested as orbit is not loaded and therefore the provider is not available
+EmbarkJS.Messages.Orbit.isAvailable = function(){
+    return new Promise((resolve) => {
+        if(!this.orbit) resolve(false);
+        resolve(true);
+    });
+}

lib/core/config.js

@@ -103,7 +103,9 @@ Config.prototype._getFileOrOject = function(object, filePath, property) {
 Config.prototype.loadBlockchainConfigFile = function() {
   var configObject = {
     "default": {
-      "enabled": true
+      "enabled": true,
+      "rpcCorsDomain": "auto",
+      "wsOrigins": "auto"
     }
   };
 
@@ -181,9 +183,10 @@ Config.prototype.loadStorageConfigFile = function() {
     "default": {
       "versions": versions,
       "enabled": true,
-      "available_providers": ["ipfs"],
+      "available_providers": ["ipfs", "swarm"],
       "ipfs_bin": "ipfs",
       "provider": "ipfs",
+      "protocol": "http",
       "host": "localhost",
       "port": 5001,
       "getUrl": "http://localhost:8080/ipfs/"

lib/core/engine.js

@@ -249,7 +249,7 @@ class Engine {
     this.registerModule('swarm', {
       addCheck: this.servicesMonitor.addCheck.bind(this.servicesMonitor),
       storageConfig: this.config.storageConfig,
-      web3: _options.web3
+      bzz: _options.bzz
     });
   }
 

lib/index.js

@@ -1,5 +1,6 @@
 let async = require('async');
 const constants = require('./constants');
+const _ = require('underscore');
 // require("./utils/debug_util.js")(__filename, async);
 
 require('colors');
@@ -45,11 +46,11 @@ class Embark {
 
     if(blockchainConfig.rpcCorsDomain === 'auto') {
       if(webServerConfig) blockchainConfig.rpcCorsDomain = `http://${webServerConfig.host}:${webServerConfig.port}`;
-      if(storageConfig) blockchainConfig.rpcCorsDomain += `${blockchainConfig.rpcCorsDomain.length ? ',' : ''}http://${storageConfig.host}:${storageConfig.port}`;
+      if(storageConfig) blockchainConfig.rpcCorsDomain += `${blockchainConfig.rpcCorsDomain.length ? ',' : ''}${storageConfig.protocol}://${storageConfig.host}:${storageConfig.port}`;
     }
     if(blockchainConfig.wsOrigins === 'auto') {
       if(webServerConfig) blockchainConfig.wsOrigins = `http://${webServerConfig.host}:${webServerConfig.port}`;
-      if(storageConfig) blockchainConfig.wsOrigins += `${blockchainConfig.wsOrigins.length ? ',' : ''}http://${storageConfig.host}:${storageConfig.port}`;
+      if(storageConfig) blockchainConfig.wsOrigins += `${blockchainConfig.wsOrigins.length ? ',' : ''}${storageConfig.protocol}://${storageConfig.host}:${storageConfig.port}`;
     }
     return require('./cmds/blockchain/blockchain.js')(blockchainConfig, client, env).run();
   }
@@ -127,7 +128,7 @@ class Embark {
         engine.startService("pipeline");
         engine.startService("codeGenerator");
         engine.startService("deployment");
-        engine.startService("ipfs");
+        engine.startService(engine.config.storageConfig.provider, {bzz: engine.web3.bzz});
 
         engine.events.on('check:backOnline:Ethereum', function () {
           engine.logger.info('Ethereum node detected..');
@@ -140,6 +141,7 @@ class Embark {
         engine.events.on('outputDone', function () {
           engine.logger.info("Looking for documentation? You can find it at ".cyan + "http://embark.readthedocs.io/".green.underline + ".".cyan);
           engine.logger.info("Ready".underline);
+          engine.events.emit("status", "Ready".green);
         });
 
         engine.deployManager.deployContracts(function (err) {
@@ -159,7 +161,6 @@ class Embark {
         engine.logger.info(err.stack);
       } else {
         engine.events.emit('firstDeploymentDone');
-        engine.events.emit("status", "Ready".green);
 
         let size = windowSize.get();
         if (size.height < 40 || size.width < 118) {
@@ -200,6 +201,7 @@ class Embark {
         engine.startService("codeGenerator");
         engine.startService("deployment");
         engine.startService("ipfs");
+        engine.startService("swarm", {bzz: engine.web3.bzz});
         callback();
       },
       function deploy(callback) {
@@ -309,10 +311,28 @@ class Embark {
         engine.startService("pipeline");
         engine.startService("codeGenerator");
         engine.startService("deployment");
-        engine.startService("ipfs");
-        engine.startService("swarm", {buildDir:'dist/',web3: engine.web3});
+        engine.startService(platform.toLowerCase(), {bzz: engine.web3.bzz});
+        engine.startMonitor();
         callback();
       },
+      function checkStorageService(callback){
+        let checkFn; 
+        _.find(engine.servicesMonitor.checkList, (value, key) => {
+          if(key.toLowerCase() === platform.toLowerCase()){
+            checkFn = value;
+            return true;
+          }
+        });
+        if (!checkFn || typeof checkFn.fn !== 'function') {
+          return callback();
+        }
+        checkFn.fn(function (serviceCheckResult) {
+          if (!serviceCheckResult.status || serviceCheckResult.status === 'off') {
+            return callback({message: `Cannot upload: ${platform} node is not running on http://${engine.config.storageConfig.host}:${engine.config.storageConfig.port}.`});
+          }
+          callback();
+        });
+      },
       function setupStoragePlugin(callback){
         let pluginList = engine.plugins.listPlugins();
         if (pluginList.length > 0) {
@@ -331,10 +351,9 @@ class Embark {
         }
         if (!cmdPlugin) {
           engine.logger.info('try "embark upload ipfs" or "embark upload swarm"'.green);
-          callback({message: 'unknown platform: ' + platform});
-        } else {
-          callback();
+          return callback({message: 'unknown platform: ' + platform});
         }
+        callback();
       },
       function deploy(callback) {
         // 2. upload to storage (outputDone event triggered after webpack finished)

lib/modules/ipfs/embarkjs.js

@@ -2,9 +2,9 @@ import IpfsApi from 'ipfs-api';
 
 let __embarkIPFS = {};
 
-__embarkIPFS.setProvider = function(options) {
+__embarkIPFS.setProvider = function (options) {
   var self = this;
-  var promise = new Promise(function(resolve, reject) {
+  var promise = new Promise(function (resolve, reject) {
     try {
       if (options === undefined) {
         self.ipfsConnection = IpfsApi('localhost', '5001');
@@ -30,14 +30,14 @@ __embarkIPFS.setProvider = function(options) {
   return promise;
 };
 
-__embarkIPFS.saveText = function(text) {
+__embarkIPFS.saveText = function (text) {
   const self = this;
-  var promise = new Promise(function(resolve, reject) {
+  var promise = new Promise(function (resolve, reject) {
     if (!self.ipfsConnection) {
       var connectionError = new Error('No IPFS connection. Please ensure to call Embark.Storage.setProvider()');
       reject(connectionError);
     }
-    self.ipfsConnection.add(self.ipfsConnection.Buffer.from(text), function(err, result) {
+    self.ipfsConnection.add(self.ipfsConnection.Buffer.from(text), function (err, result) {
       if (err) {
         reject(err);
       } else {
@@ -49,11 +49,11 @@ __embarkIPFS.saveText = function(text) {
   return promise;
 };
 
-__embarkIPFS.get = function(hash) {
+__embarkIPFS.get = function (hash) {
   const self = this;
   // TODO: detect type, then convert if needed
   //var ipfsHash = web3.toAscii(hash);
-  var promise = new Promise(function(resolve, reject) {
+  var promise = new Promise(function (resolve, reject) {
     if (!self.ipfsConnection) {
       var connectionError = new Error('No IPFS connection. Please ensure to call Embark.Storage.setProvider()');
       reject(connectionError);
@@ -69,24 +69,24 @@ __embarkIPFS.get = function(hash) {
   return promise;
 };
 
-__embarkIPFS.uploadFile = function(inputSelector) {
+__embarkIPFS.uploadFile = function (inputSelector) {
   const self = this;
   var file = inputSelector[0].files[0];
 
   if (file === undefined) {
     throw new Error('no file found');
   }
 
-  var promise = new Promise(function(resolve, reject) {
+  var promise = new Promise(function (resolve, reject) {
     if (!self.ipfsConnection) {
       var connectionError = new Error('No IPFS connection. Please ensure to call Embark.Storage.setProvider()');
       reject(connectionError);
     }
     var reader = new FileReader();
-    reader.onloadend = function() {
+    reader.onloadend = function () {
       var fileContent = reader.result;
       var buffer = self.ipfsConnection.Buffer.from(fileContent);
-      self.ipfsConnection.add(buffer, function(err, result) {
+      self.ipfsConnection.add(buffer, function (err, result) {
         if (err) {
           reject(err);
         } else {
@@ -100,7 +100,22 @@ __embarkIPFS.uploadFile = function(inputSelector) {
   return promise;
 };
 
-__embarkIPFS.getUrl = function(hash) {
+__embarkIPFS.isAvailable = function () {
+  return new Promise((resolve) => {
+    if (!this.ipfsConnection) {
+      return resolve(false);
+    }
+    this.ipfsConnection.id()
+      .then((id) => {
+        resolve(Boolean(id));
+      })
+      .catch(() => {
+        resolve(false);
+      });
+  });
+};
+
+__embarkIPFS.getUrl = function (hash) {
   return (this._getUrl || "http://localhost:8080/ipfs/") + hash;
 };
 

lib/modules/ipfs/upload.js

@@ -29,7 +29,7 @@ class IPFS {
         function runCommand(ipfs_bin, callback) {
           let cmd = `"${ipfs_bin}" add -r ${self.buildDir}`;
           console.log(("=== adding " + self.buildDir + " to ipfs").green);
-          console.trace(cmd);
+          console.debug(cmd);
           shelljs.exec(cmd, {silent:true}, function(code, stdout, stderr){ // {silent:true}: don't echo cmd output so it can be controlled via logLevel
             console.log(stdout.green);
             callback(stderr, stdout);

lib/modules/swarm/embarkjs.js

@@ -0,0 +1,94 @@
+/*global web3 */
+let __embarkSwarm = {};
+const bytes = require("eth-lib/lib/bytes");
+
+__embarkSwarm.setProvider = function (options) {
+  this.bzz = web3.bzz;
+  this.protocol = options.protocol;
+  this.host = options.host;
+  this.port = options.port;
+  this.connectUrl = `${options.protocol}://${options.host}:${options.port}`;
+  this.connectError = new Error(`Cannot connect to Swarm node on ${this.connectUrl}`);
+  this._getUrl = options.getUrl || `${this.connectUrl}/bzzr:/`;
+
+  return new Promise((resolve, reject) => {
+    try {
+      if (!this.bzz.currentProvider) {
+        this.bzz.setProvider(`${options.protocol}://${options.host}:${options.port}`);
+      }
+      resolve(this);
+    } catch (err) {
+      console.log(err);
+      reject(this.connectError);
+    }
+  });
+};
+
+__embarkSwarm.isAvailable = function () {
+  return new Promise((resolve, reject) => {
+    if (!this.bzz) {
+      return resolve(false);
+    }
+    this.bzz.isAvailable()
+      .then(resolve)
+      .catch(() => {
+        reject(this.connectError);
+      });
+  });
+};
+
+__embarkSwarm.saveText = function (text) {
+  return new Promise((resolve, reject) => {
+    this.isAvailable().then((isAvailable) => {
+      if (!isAvailable) {
+        return reject(this.connectError);
+      }
+      this.bzz.upload(text)
+        .then(resolve)
+        .catch(reject);
+    }).catch(reject);
+  });
+};
+
+__embarkSwarm.get = function (hash) {
+  return new Promise((resolve, reject) => {
+    this.isAvailable().then((isAvailable) => {
+      if (!isAvailable) {
+        return reject(this.connectError);
+      }
+      this.bzz.download(hash)
+        .then((uint8Array) => resolve(bytes.toString(bytes.fromUint8Array(uint8Array))))
+        .catch(reject);
+    }).catch(reject);
+  });
+};
+
+__embarkSwarm.uploadFile = function (inputSelector) {
+  let file = inputSelector[0].files[0];
+
+  if (file === undefined) {
+    throw new Error('no file found');
+  }
+
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = (event) => {
+      const fileContent = new Uint8Array(event.target.result);
+      this.isAvailable().then((isAvailable) => {
+        if (!isAvailable) {
+          return reject(this.connectError);
+        }
+        this.bzz.upload(fileContent)
+          .then(resolve)
+          .catch(reject);
+      }).catch(reject);
+    };
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(file);
+  });
+};
+
+__embarkSwarm.getUrl = function (hash) {
+  return this._getUrl + hash;
+};
+