Spawn

8 files changed, 979 insertions, 0 deletions

diff --git a/src/checker.js b/src/checker.js
new file mode 100644
index 000000000..fd828ca8c
--- /dev/null
+++ b/src/checker.js
@@ -0,0 +1,45 @@
+;(function () {
+  'use strict'
+
+  var config = require('config')
+  var mkdirp = require('mkdirp')
+
+  var checker = {}
+
+  // Check the config files
+  checker.checkConfig = function () {
+    var required = [ 'listen.port',
+      'webserver.https', 'webserver.host', 'webserver.port',
+      'database.host', 'database.port', 'database.suffix',
+      'storage.certs', 'storage.uploads', 'storage.logs',
+      'network.friends' ]
+    var miss = []
+
+    for (var key of required) {
+      if (!config.has(key)) {
+        miss.push(key)
+      }
+    }
+
+    return miss
+  }
+
+  // Create directories for the storage if it doesn't exist
+  checker.createDirectories = function () {
+    var storages = config.get('storage')
+
+    for (var key of Object.keys(storages)) {
+      var path = storages[key]
+      try {
+        mkdirp.sync(__dirname + '/../' + path)
+      } catch (error) {
+        // Do not use logger
+        console.error('Cannot create ' + path + ':' + error)
+        process.exit(0)
+      }
+    }
+  }
+
+  // ----------- Export -----------
+  module.exports = checker
+})()
diff --git a/src/database.js b/src/database.js
new file mode 100644
index 000000000..6fbd5dbc8
--- /dev/null
+++ b/src/database.js
@@ -0,0 +1,49 @@
+;(function () {
+  'use strict'
+
+  var config = require('config')
+  var mongoose = require('mongoose')
+
+  var logger = require('./logger')
+
+  var dbname = 'petube' + config.get('database.suffix')
+  var host = config.get('database.host')
+  var port = config.get('database.port')
+
+  // ----------- Videos -----------
+  var videosSchema = mongoose.Schema({
+    name: String,
+    namePath: String,
+    description: String,
+    magnetUri: String,
+    podUrl: String
+  })
+
+  var VideosDB = mongoose.model('videos', videosSchema)
+
+  // ----------- Pods -----------
+  var podsSchema = mongoose.Schema({
+    url: String,
+    publicKey: String
+  })
+
+  var PodsDB = mongoose.model('pods', podsSchema)
+
+  // ----------- Connection -----------
+
+  mongoose.connect('mongodb://' + host + ':' + port + '/' + dbname)
+  mongoose.connection.on('error', function () {
+    logger.error('Mongodb connection error.')
+    process.exit(0)
+  })
+
+  mongoose.connection.on('open', function () {
+    logger.info('Connected to mongodb.')
+  })
+
+  // ----------- Export -----------
+  module.exports = {
+    VideosDB: VideosDB,
+    PodsDB: PodsDB
+  }
+})()
diff --git a/src/logger.js b/src/logger.js
new file mode 100644
index 000000000..b1384e8b9
--- /dev/null
+++ b/src/logger.js
@@ -0,0 +1,41 @@
+;(function () {
+  // Thanks http://tostring.it/2014/06/23/advanced-logging-with-nodejs/
+
+  'use strict'
+
+  var winston = require('winston')
+  var config = require('config')
+
+  var logDir = __dirname + '/../' + config.get('storage.logs')
+
+  winston.emitErrs = true
+
+  var logger = new winston.Logger({
+    transports: [
+      new winston.transports.File({
+        level: 'debug',
+        filename: logDir + '/all-logs.log',
+        handleExceptions: true,
+        json: true,
+        maxsize: 5242880,
+        maxFiles: 5,
+        colorize: false
+      }),
+      new winston.transports.Console({
+        level: 'debug',
+        handleExceptions: true,
+        humanReadableUnhandledException: true,
+        json: false,
+        colorize: true
+      })
+    ],
+    exitOnError: true
+  })
+
+  module.exports = logger
+  module.exports.stream = {
+    write: function (message, encoding) {
+      logger.info(message)
+    }
+  }
+})()
diff --git a/src/pods.js b/src/pods.js
new file mode 100644
index 000000000..9d6539685
--- /dev/null
+++ b/src/pods.js
@@ -0,0 +1,177 @@
+;(function () {
+  'use strict'
+
+  var fs = require('fs')
+  var config = require('config')
+  var async = require('async')
+  var request = require('request')
+
+  var logger = require('./logger')
+  var utils = require('./utils')
+  var PodsDB = require('./database').PodsDB
+
+  var pods = {}
+  var http = config.get('webserver.https') ? 'https' : 'http'
+  var host = config.get('webserver.host')
+  var port = config.get('webserver.port')
+
+  // ----------- Private functions -----------
+
+  function getForeignPodsList (url, callback) {
+    var path = '/api/pods'
+
+    request.get(url + path, function (err, response, body) {
+      if (err) throw err
+      callback(JSON.parse(body))
+    })
+  }
+
+  // ----------- Public functions -----------
+  pods.list = function (callback) {
+    PodsDB.find(function (err, pods_list) {
+      if (err) {
+        logger.error('Cannot get the list of the pods.', { error: err })
+        return callback(err)
+      }
+
+      return callback(null, pods_list)
+    })
+  }
+
+  // { url }
+  pods.add = function (data, callback) {
+    logger.info('Adding pod: %s', data.url)
+
+    var params = {
+      url: data.url,
+      publicKey: data.publicKey
+    }
+
+    PodsDB.create(params, function (err, pod) {
+      if (err) {
+        logger.error('Cannot insert the pod.', { error: err })
+        return callback(err)
+      }
+
+      fs.readFile(utils.certDir + 'petube.pub', 'utf8', function (err, cert) {
+        if (err) {
+          logger.error('Cannot read cert file.', { error: err })
+          return callback(err)
+        }
+
+        return callback(null, { cert: cert })
+      })
+    })
+  }
+
+  // { path, data }
+  pods.makeSecureRequest = function (data, callback) {
+    PodsDB.find({}, { url: 1, publicKey: 1 }).exec(function (err, urls) {
+      if (err) {
+        logger.error('Cannot get the list of the pods.', { error: err })
+        return callback(err)
+      }
+
+      logger.debug('Make multiple requests.')
+      utils.makeMultipleRetryRequest(
+        { encrypt: true, sign: true, method: data.method, path: data.path, data: data.data },
+
+        urls,
+
+        function (err, response, body, url) {
+          if (err || response.statusCode !== 200) {
+            logger.error('Error sending secure request to %s/%s pod.', url, data.path, { error: err })
+          }
+        },
+
+        function (err) {
+          if (err) {
+            logger.error('There was some errors when sending the video meta data.', { error: err })
+            return callback(err)
+          }
+
+          logger.debug('Finished')
+          callback(null)
+        }
+      )
+    })
+  }
+
+  pods.makeFriends = function (callback) {
+    logger.debug('Read public key...')
+    fs.readFile(utils.certDir + 'petube.pub', 'utf8', function (err, cert) {
+      if (err) {
+        logger.error('Cannot read public cert.', { error: err })
+        return callback(err)
+      }
+
+      var urls = config.get('network.friends')
+      var pods_score = {}
+
+      async.each(urls, function (url, callback) {
+        // Always add a trust pod
+        pods_score[url] = Infinity
+
+        getForeignPodsList(url, function (foreign_pods_list) {
+          if (foreign_pods_list.length === 0) return callback()
+
+          async.each(foreign_pods_list, function (foreign_pod, callback) {
+            var foreign_url = foreign_pod.url
+            if (pods_score[foreign_url]) pods_score[foreign_url]++
+            else pods_score[foreign_url] = 1
+            callback()
+          }, callback)
+        })
+      }, function () {
+        logger.debug('Pods score', { pods_score: pods_score })
+
+        // Build the list of pods to add
+        // Only add a pod if it exists in more than a half base pods
+        var pods_list = []
+        var base_score = urls.length / 2
+        Object.keys(pods_score).forEach(function (pod) {
+          if (pods_score[pod] > base_score) pods_list.push({ url: pod })
+        })
+
+        logger.debug('Pods that we keep', { pods: pods_list })
+
+        var data = {
+          url: http + '://' + host + ':' + port,
+          publicKey: cert
+        }
+
+        logger.debug('Make requests...')
+
+        utils.makeMultipleRetryRequest(
+          { method: 'POST', path: '/api/pods/', data: data },
+
+          pods_list,
+
+          function eachRequest (err, response, body, url) {
+            if (!err && response.statusCode === 200) {
+              pods.add({ url: url, publicKey: body.cert }, function (err) {
+                if (err) {
+                  logger.error('Error with adding %s pod.', url, { error: err })
+                }
+              })
+            } else {
+              logger.error('Error with adding %s pod.', url)
+            }
+          },
+
+          function endRequests (err) {
+            if (err) {
+              logger.error('There was some errors when we wanted to make friends.', { error: err })
+              return callback(err)
+            }
+
+            logger.debug('Finished')
+            callback(null)
+          }
+        )
+      })
+    })
+  }
+
+  module.exports = pods
+})()
diff --git a/src/utils.js b/src/utils.js
new file mode 100644
index 000000000..0b21565dd
--- /dev/null
+++ b/src/utils.js
@@ -0,0 +1,190 @@
+;(function () {
+  'use strict'
+
+  var request = require('request')
+  var replay = require('request-replay')
+  var ursa = require('ursa')
+  var config = require('config')
+  var fs = require('fs')
+  var openssl = require('openssl-wrapper')
+  var crypto = require('crypto')
+
+  var logger = require('./logger')
+
+  var http = config.get('webserver.https') ? 'https' : 'http'
+  var host = config.get('webserver.host')
+  var port = config.get('webserver.port')
+  var algorithm = 'aes-256-ctr'
+
+  var utils = {}
+
+  // ----------- Private functions ----------
+
+  function makeRetryRequest (params, from_url, to_pod, signature, callbackEach) {
+    // Append the signature
+    if (signature) {
+      params.json.signature = {
+        url: from_url,
+        signature: signature
+      }
+    }
+
+    logger.debug('Sending informations to %s', to_pod.url, { params: params })
+
+    // Replay 15 times, with factor 3
+    replay(
+      request.post(params, function (err, response, body) {
+        callbackEach(err, response, body, to_pod.url)
+      }),
+      {
+        retries: 10,
+        factor: 3,
+        maxTimeout: Infinity,
+        errorCodes: [ 'EADDRINFO', 'ETIMEDOUT', 'ECONNRESET', 'ESOCKETTIMEDOUT', 'ENOTFOUND', 'ECONNREFUSED' ]
+      }
+    ).on('replay', function (replay) {
+      logger.info('Replaying request to %s. Request failed: %d %s. Replay number: #%d. Will retry in: %d ms.',
+        params.url, replay.error.code, replay.error.message, replay.number, replay.delay)
+    })
+  }
+
+  // ----------- Public attributes ----------
+  utils.certDir = __dirname + '/../' + config.get('storage.certs')
+
+  // { path, data }
+  utils.makeMultipleRetryRequest = function (all, pods, callbackEach, callback) {
+    if (!callback) {
+      callback = callbackEach
+      callbackEach = function () {}
+    }
+
+    var url = http + '://' + host + ':' + port
+    var signature
+
+    // Signature ?
+    if (all.method === 'POST' && all.data && all.sign === true) {
+      var myKey = ursa.createPrivateKey(fs.readFileSync(utils.certDir + 'petube.key.pem'))
+      signature = myKey.hashAndSign('sha256', url, 'utf8', 'hex')
+    }
+
+    // Make a request for each pod
+    for (var pod of pods) {
+      var params = {
+        url: pod.url + all.path,
+        method: all.method
+      }
+
+      // Add data with POST requst ?
+      if (all.method === 'POST' && all.data) {
+        logger.debug('Make a POST request.')
+
+        // Encrypt data ?
+        if (all.encrypt === true) {
+          logger.debug(pod.publicKey)
+          var crt = ursa.createPublicKey(pod.publicKey)
+
+          // TODO: ES6 with let
+          ;(function (crt_copy, copy_params, copy_url, copy_pod, copy_signature) {
+            utils.symetricEncrypt(JSON.stringify(all.data), function (err, dataEncrypted) {
+              if (err) throw err
+
+              var passwordEncrypted = crt_copy.encrypt(dataEncrypted.password, 'utf8', 'hex')
+              copy_params.json = {
+                data: dataEncrypted.crypted,
+                key: passwordEncrypted
+              }
+
+              makeRetryRequest(copy_params, copy_url, copy_pod, copy_signature, callbackEach)
+            })
+          })(crt, params, url, pod, signature)
+        } else {
+          params.json = { data: all.data }
+          makeRetryRequest(params, url, pod, signature, callbackEach)
+        }
+      } else {
+        logger.debug('Make a GET/DELETE request')
+        makeRetryRequest(params, url, pod, signature, callbackEach)
+      }
+    }
+
+    return callback()
+  }
+
+  utils.certsExist = function (callback) {
+    fs.exists(utils.certDir + 'petube.key.pem', function (exists) {
+      return callback(exists)
+    })
+  }
+
+  utils.createCerts = function (callback) {
+    utils.certsExist(function (exist) {
+      if (exist === true) {
+        var string = 'Certs already exist.'
+        logger.warning(string)
+        return callback(new Error(string))
+      }
+
+      logger.debug('Gen RSA keys...')
+      openssl.exec('genrsa', { 'out': utils.certDir + 'petube.key.pem' }, function (err) {
+        if (err) {
+          logger.error('Cannot create private key on this pod.', { error: err })
+          return callback(err)
+        }
+
+        logger.debug('Manage public key...')
+        openssl.exec('rsa', { 'in': utils.certDir + 'petube.key.pem', 'pubout': true, 'out': utils.certDir + 'petube.pub' }, function (err) {
+          if (err) {
+            logger.error('Cannot create public key on this pod .', { error: err })
+            return callback(err)
+          }
+
+          return callback(null)
+        })
+      })
+    })
+  }
+
+  utils.createCertsIfNotExist = function (callback) {
+    utils.certsExist(function (exist) {
+      if (exist === true) {
+        return callback(null)
+      }
+
+      utils.createCerts(function (err) {
+        return callback(err)
+      })
+    })
+  }
+
+  utils.generatePassword = function (callback) {
+    crypto.randomBytes(32, function (err, buf) {
+      if (err) {
+        return callback(err)
+      }
+
+      callback(null, buf.toString('utf8'))
+    })
+  }
+
+  utils.symetricEncrypt = function (text, callback) {
+    utils.generatePassword(function (err, password) {
+      if (err) {
+        return callback(err)
+      }
+
+      var cipher = crypto.createCipher(algorithm, password)
+      var crypted = cipher.update(text, 'utf8', 'hex')
+      crypted += cipher.final('hex')
+      callback(null, { crypted: crypted, password: password })
+    })
+  }
+
+  utils.symetricDecrypt = function (text, password) {
+    var decipher = crypto.createDecipher(algorithm, password)
+    var dec = decipher.update(text, 'hex', 'utf8')
+    dec += decipher.final('utf8')
+    return dec
+  }
+
+  module.exports = utils
+})()
diff --git a/src/videos.js b/src/videos.js
new file mode 100644
index 000000000..605ce098f
--- /dev/null
+++ b/src/videos.js
@@ -0,0 +1,245 @@
+;(function () {
+  'use strict'
+
+  var fs = require('fs')
+  var webtorrent = require('./webTorrentNode')
+  var config = require('config')
+  var async = require('async')
+
+  var logger = require('./logger')
+  var VideosDB = require('./database').VideosDB
+  var pods = require('./pods')
+
+  var videos = {}
+  // Public url
+  var http = config.get('webserver.https') === true ? 'https' : 'http'
+  var host = config.get('webserver.host')
+  var port = config.get('webserver.port')
+
+  // ----------- Private functions -----------
+  function seedVideo (path, callback) {
+    logger.debug('Seeding : %s', path)
+
+    webtorrent.seed(path, function (torrent) {
+      logger.debug('Seeded : %s', torrent.magnetURI)
+
+      return callback(null, torrent)
+    })
+  }
+
+  // ----------- Public attributes ----------
+  videos.uploadDir = __dirname + '/../' + config.get('storage.uploads')
+
+  // ----------- Public functions -----------
+  videos.list = function (callback) {
+    VideosDB.find(function (err, videos_list) {
+      if (err) {
+        logger.error('Cannot get list of the videos.', { error: err })
+        return callback(err)
+      }
+
+      return callback(null, videos_list)
+    })
+  }
+
+  videos.add = function (data, callback) {
+    var video_file = data.video
+    var video_data = data.data
+
+    logger.debug('Path: %s', video_file.path)
+    seedVideo(video_file.path, function (err, torrent) {
+      if (err) {
+        logger.error('Cannot seed this video.', { error: err })
+        return callback(err)
+      }
+
+      var params = {
+        name: video_data.name,
+        namePath: video_file.name,
+        description: video_data.description,
+        magnetUri: torrent.magnetURI,
+        podUrl: http + '://' + host + ':' + port
+      }
+
+      VideosDB.create(params, function (err, video) {
+        if (err) {
+          logger.error('Cannot insert this video.', { error: err })
+          return callback(err)
+        }
+
+        // Now we'll send the video's meta data
+        params.namePath = null
+
+        logger.debug('Sending this video Uri to friends...')
+
+        var data = {
+          path: '/api/remotevideos/add',
+          method: 'POST',
+          data: params
+        }
+
+        pods.makeSecureRequest(data, function (err) {
+          if (err) {
+            logger.error('Somes issues when sending this video to friends.', { error: err })
+            return callback(err)
+          }
+
+          return callback(null)
+        })
+      })
+    })
+  }
+
+  videos.remove = function (id, callback) {
+    // Maybe the torrent is not seeding, it doesn't have importance
+    function removeTorrent (magnetUri, callback) {
+      try {
+        webtorrent.remove(magnetUri, callback)
+      } catch (err) {
+        logger.warn('Cannot remove the torrent from WebTorrent', { err: err })
+        return callback(null)
+      }
+    }
+
+    VideosDB.findById(id, function (err, video) {
+      if (err || !video) {
+        logger.error('Cannot find this video.', { error: err })
+        return callback(err)
+      }
+
+      if (video.namePath === null) {
+        var error_string = 'Cannot remove the video of another pod.'
+        logger.error(error_string)
+        return callback(new Error(error_string))
+      }
+
+      logger.debug('Removing video %s', video.magnetUri)
+
+      removeTorrent(video.magnetUri, function () {
+        VideosDB.findByIdAndRemove(id, function (err) {
+          if (err) {
+            logger.error('Cannot remove the torrent.', { error: err })
+            return callback(err)
+          }
+
+          fs.unlink(videos.uploadDir + video.namePath, function (err) {
+            if (err) {
+              logger.error('Cannot remove this video file.', { error: err })
+              return callback(err)
+            }
+
+            var data = {
+              path: '/api/remotevideos/remove',
+              method: 'POST',
+              data: {
+                magnetUri: video.magnetUri
+              }
+            }
+
+            // Yes this is a POST request because we add some informations in the body (signature, encrypt etc)
+            pods.makeSecureRequest(data, function (err) {
+              if (err) {
+                logger.error('Somes issues when sending we want to remove the video to friends.', { error: err })
+                return callback(err)
+              }
+
+              callback(null)
+            })
+          })
+        })
+      })
+    })
+  }
+
+  // Use the magnet Uri because the _id field is not the same on different servers
+  videos.removeRemote = function (fromUrl, magnetUri, callback) {
+    // TODO : check if the remote server has the rights to remove this video
+
+    VideosDB.findOne({ magnetUri: magnetUri }, function (err, video) {
+      if (err || !video) {
+        logger.error('Cannot find the torrent URI of this remote video.')
+        return callback(err)
+      }
+
+      if (video.podUrl !== fromUrl) {
+        logger.error('The pod has not rights on this video.')
+        return callback(err)
+      }
+
+      VideosDB.findByIdAndRemove(video._id, function (err) {
+        if (err) {
+          logger.error('Cannot remove the remote video.')
+          return callback(err)
+        }
+
+        callback(null)
+      })
+    })
+  }
+
+  // { name, magnetUri, podUrl }
+  videos.addRemote = function (data, callback) {
+    logger.debug('Add remote video from pod: %s', data.podUrl)
+
+    var params = {
+      name: data.name,
+      namePath: null,
+      description: data.description,
+      magnetUri: data.magnetUri,
+      podUrl: data.podUrl
+    }
+
+    VideosDB.create(params, function (err, video) {
+      if (err) {
+        logger.error('Cannot insert this remote video.', { error: err })
+        return callback(err)
+      }
+
+      return callback(null, video)
+    })
+  }
+
+  videos.get = function (id, callback) {
+    VideosDB.findById(id, function (err, video) {
+      if (err) {
+        logger.error('Cannot get this video.', { error: err })
+        return callback(err)
+      }
+
+      return callback(null, video)
+    })
+  }
+
+  videos.search = function (name, callback) {
+    VideosDB.find({ name: new RegExp(name) }, function (err, videos) {
+      if (err) {
+        logger.error('Cannot search the videos.', { error: err })
+        return callback(err)
+      }
+
+      return callback(null, videos)
+    })
+  }
+
+  videos.seedAll = function (final_callback) {
+    VideosDB.find({ namePath: { $ne: null } }, function (err, videos_list) {
+      if (err) {
+        logger.error('Cannot get list of the videos to seed.', { error: err })
+        return final_callback(err)
+      }
+
+      async.each(videos_list, function (video, callback) {
+        seedVideo(videos.uploadDir + video.namePath, function (err) {
+          if (err) {
+            logger.error('Cannot seed this video.', { error: err })
+            return callback(err)
+          }
+
+          callback(null)
+        })
+      }, final_callback)
+    })
+  }
+
+  module.exports = videos
+})()
diff --git a/src/webTorrentNode.js b/src/webTorrentNode.js
new file mode 100644
index 000000000..03bff7803
--- /dev/null
+++ b/src/webTorrentNode.js
@@ -0,0 +1,145 @@
+;(function () {
+  'use strict'
+
+  var spawn = require('electron-spawn')
+  var config = require('config')
+  var ipc = require('node-ipc')
+  var pathUtils = require('path')
+
+  var logger = require('./logger')
+
+  var host
+  var port
+
+  try {
+    host = config.get('webserver.host')
+    port = config.get('webserver.port')
+  } catch (e) {
+    host = 'client'
+    port = 1
+  }
+
+  var nodeKey = 'webtorrentnode' + port
+  var processKey = 'webtorrent' + port
+
+  ipc.config.silent = true
+  ipc.config.id = nodeKey
+
+  var webtorrentnode = {}
+
+  // Useful for beautiful tests
+  webtorrentnode.silent = false
+
+  // Useful to kill it
+  webtorrentnode.app = null
+
+  webtorrentnode.create = function (callback) {
+    ipc.serve(function () {
+      if (!webtorrentnode.silent) logger.info('IPC server ready.')
+
+      ipc.server.on(processKey + '.ready', function () {
+        if (!webtorrentnode.silent) logger.info('Webtorrent process ready.')
+        callback()
+      })
+
+      var webtorrent_process = spawn(__dirname + '/webtorrent.js', host, port, { detached: true })
+      webtorrent_process.stderr.on('data', function (data) {
+        // logger.debug('Webtorrent process stderr: ', data.toString())
+      })
+
+      webtorrent_process.stdout.on('data', function (data) {
+        // logger.debug('Webtorrent process:', data.toString())
+      })
+
+      function exitChildProcess () {
+        if (!webtorrentnode.silent) logger.info('Gracefully exit child')
+        process.kill(-webtorrent_process.pid)
+        process.exit(0)
+      }
+
+      process.on('SIGINT', exitChildProcess)
+      process.on('SIGTERM', exitChildProcess)
+
+      webtorrentnode.app = webtorrent_process
+    })
+
+    ipc.server.start()
+  }
+
+  webtorrentnode.seed = function (path, callback) {
+    var extension = pathUtils.extname(path)
+    var basename = pathUtils.basename(path, extension)
+    var data = {
+      _id: basename,
+      args: {
+        path: path
+      }
+    }
+
+    if (!webtorrentnode.silent) logger.debug('Node wants to seed ' + data._id)
+
+    // Finish signal
+    ipc.server.on(nodeKey + '.seedDone.' + data._id, function (received) {
+      if (!webtorrentnode.silent) logger.debug('Process seeded torrent ' + received.magnetUri)
+
+      // This is a fake object, we just use the magnetUri in this project
+      var torrent = {
+        magnetURI: received.magnetUri
+      }
+
+      callback(torrent)
+    })
+
+    ipc.server.broadcast(processKey + '.seed', data)
+  }
+
+  webtorrentnode.add = function (magnetUri, callback) {
+    var data = {
+      _id: magnetUri,
+      args: {
+        magnetUri: magnetUri
+      }
+    }
+
+    if (!webtorrentnode.silent) logger.debug('Node wants to add ' + data._id)
+
+    // Finish signal
+    ipc.server.on(nodeKey + '.addDone.' + data._id, function (received) {
+      if (!webtorrentnode.silent) logger.debug('Process added torrent')
+
+      // This is a fake object, we just use the magnetUri in this project
+      var torrent = {
+        files: received.files
+      }
+
+      callback(torrent)
+    })
+
+    ipc.server.broadcast(processKey + '.add', data)
+  }
+
+  webtorrentnode.remove = function (magnetUri, callback) {
+    var data = {
+      _id: magnetUri,
+      args: {
+        magnetUri: magnetUri
+      }
+    }
+
+    if (!webtorrentnode.silent) logger.debug('Node wants to stop seeding ' + data._id)
+
+    // Finish signal
+    ipc.server.on(nodeKey + '.removeDone.' + data._id, function (received) {
+      if (!webtorrentnode.silent) logger.debug('Process removed torrent ' + data._id)
+
+      var err = null
+      if (received.err) err = received.err
+
+      callback(err)
+    })
+
+    ipc.server.broadcast(processKey + '.remove', data)
+  }
+
+  module.exports = webtorrentnode
+})()
diff --git a/src/webtorrent.js b/src/webtorrent.js
new file mode 100644
index 000000000..840f97671
--- /dev/null
+++ b/src/webtorrent.js
@@ -0,0 +1,87 @@
+;(function () {
+  'use strict'
+
+  module.exports = function (args) {
+    var WebTorrent = require('webtorrent')
+    var ipc = require('node-ipc')
+
+    if (args.length !== 3) {
+      console.log('Wrong arguments number: ' + args.length + '/3')
+      process.exit(-1)
+    }
+
+    var host = args[1]
+    var port = args[2]
+    var nodeKey = 'webtorrentnode' + port
+    var processKey = 'webtorrent' + port
+
+    ipc.config.silent = true
+    ipc.config.id = processKey
+
+    if (host === 'client' && port === '1') global.WEBTORRENT_ANNOUNCE = []
+    else global.WEBTORRENT_ANNOUNCE = 'ws://' + host + ':' + port + '/tracker/socket'
+    var wt = new WebTorrent({ dht: false })
+
+    function seed (data) {
+      var args = data.args
+      var path = args.path
+      var _id = data._id
+
+      wt.seed(path, function (torrent) {
+        var to_send = {
+          magnetUri: torrent.magnetURI
+        }
+
+        ipc.of[nodeKey].emit(nodeKey + '.seedDone.' + _id, to_send)
+      })
+    }
+
+    function add (data) {
+      var args = data.args
+      var magnetUri = args.magnetUri
+      var _id = data._id
+
+      wt.add(magnetUri, function (torrent) {
+        var to_send = {
+          files: []
+        }
+
+        torrent.files.forEach(function (file) {
+          to_send.files.push({ path: file.path })
+        })
+
+        ipc.of[nodeKey].emit(nodeKey + '.addDone.' + _id, to_send)
+      })
+    }
+
+    function remove (data) {
+      var args = data.args
+      var magnetUri = args.magnetUri
+      var _id = data._id
+
+      try {
+        wt.remove(magnetUri, callback)
+      } catch (err) {
+        console.log('Cannot remove the torrent from WebTorrent', { err: err })
+        return callback(null)
+      }
+
+      function callback () {
+        var to_send = {}
+        ipc.of[nodeKey].emit(nodeKey + '.removeDone.' + _id, to_send)
+      }
+    }
+
+    console.log('Configuration: ' + host + ':' + port)
+    console.log('Connecting to IPC...')
+
+    ipc.connectTo(nodeKey, function () {
+      ipc.of[nodeKey].on(processKey + '.seed', seed)
+      ipc.of[nodeKey].on(processKey + '.add', add)
+      ipc.of[nodeKey].on(processKey + '.remove', remove)
+
+      ipc.of[nodeKey].emit(processKey + '.ready')
+      console.log('Ready.')
+    })
+  }
+})()