Infile code reorganization

2 files changed, 182 insertions, 160 deletions

diff --git a/models/pods.js b/models/pods.js
index c8d08b26f..ed2f0d8ee 100644
--- a/models/pods.js
+++ b/models/pods.js
@@ -12,39 +12,23 @@
   var poolRequests = require('../lib/poolRequests')
   var utils = require('../helpers/utils')
 
-  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/' + constants.API_VERSION + '/pods'
-
-    request.get(url + path, function (err, response, body) {
-      if (err) throw err
-      callback(JSON.parse(body))
-    })
+  var pods = {
+    add: add,
+    addVideoToFriends: addVideoToFriends,
+    list: list,
+    hasFriends: hasFriends,
+    makeFriends: makeFriends,
+    quitFriends: quitFriends,
+    remove: remove,
+    removeVideoToFriends
   }
 
-  // ----------- 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 }
   // TODO: check if the pod is not already a friend
-  pods.add = function (data, callback) {
+  function add (data, callback) {
     var videos = require('./videos')
     logger.info('Adding pod: %s', data.url)
 
@@ -62,7 +46,7 @@
 
       videos.addRemotes(data.videos)
 
-      fs.readFile(utils.certDir + 'peertube.pub', 'utf8', function (err, cert) {
+      fs.readFile(utils.getCertDir() + 'peertube.pub', 'utf8', function (err, cert) {
         if (err) {
           logger.error('Cannot read cert file.', { error: err })
           return callback(err)
@@ -80,40 +64,38 @@
     })
   }
 
-  pods.remove = function (url, callback) {
-    var videos = require('./videos')
-    logger.info('Removing %s pod.', url)
-
-    videos.removeAllRemotesOf(url, function (err) {
-      if (err) logger.error('Cannot remove all remote videos of %s.', url)
+  function addVideoToFriends (video) {
+    // To avoid duplicates
+    var id = video.name + video.magnetUri
+    poolRequests.addToPoolRequests(id, 'add', video)
+  }
 
-      PodsDB.remove({ url: url }, function (err) {
-        if (err) return callback(err)
+  function list (callback) {
+    PodsDB.find(function (err, pods_list) {
+      if (err) {
+        logger.error('Cannot get the list of the pods.', { error: err })
+        return callback(err)
+      }
 
-        logger.info('%s pod removed.', url)
-        callback(null)
-      })
+      return callback(null, pods_list)
     })
   }
 
-  pods.addVideoToFriends = function (video) {
-    // To avoid duplicates
-    var id = video.name + video.magnetUri
-    poolRequests.addToPoolRequests(id, 'add', video)
-  }
+  function hasFriends (callback) {
+    PodsDB.count(function (err, count) {
+      if (err) return callback(err)
 
-  pods.removeVideoToFriends = function (video) {
-    // To avoid duplicates
-    var id = video.name + video.magnetUri
-    poolRequests.addToPoolRequests(id, 'remove', video)
+      var has_friends = (count !== 0)
+      callback(null, has_friends)
+    })
   }
 
-  pods.makeFriends = function (callback) {
+  function makeFriends (callback) {
     var videos = require('./videos')
     var pods_score = {}
 
     logger.info('Make friends!')
-    fs.readFile(utils.certDir + 'peertube.pub', 'utf8', function (err, cert) {
+    fs.readFile(utils.getCertDir() + 'peertube.pub', 'utf8', function (err, cert) {
       if (err) {
         logger.error('Cannot read public cert.', { error: err })
         return callback(err)
@@ -188,7 +170,7 @@
           function eachRequest (err, response, body, url, pod, callback_each_request) {
             // We add the pod if it responded correctly with its public certificate
             if (!err && response.statusCode === 200) {
-              pods.add({ url: pod.url, publicKey: body.cert, score: constants.FRIEND_BASE_SCORE }, function (err) {
+              add({ url: pod.url, publicKey: body.cert, score: constants.FRIEND_BASE_SCORE }, function (err) {
                 if (err) logger.error('Error with adding %s pod.', pod.url, { error: err })
 
                 videos.addRemotes(body.videos, function (err) {
@@ -221,7 +203,7 @@
     }
   }
 
-  pods.quitFriends = function (callback) {
+  function quitFriends (callback) {
     // Stop pool requests
     poolRequests.deactivate()
     // Flush pool requests
@@ -261,14 +243,40 @@
     })
   }
 
-  pods.hasFriends = function (callback) {
-    PodsDB.count(function (err, count) {
-      if (err) return callback(err)
+  function remove (url, callback) {
+    var videos = require('./videos')
+    logger.info('Removing %s pod.', url)
 
-      var has_friends = (count !== 0)
-      callback(null, has_friends)
+    videos.removeAllRemotesOf(url, function (err) {
+      if (err) logger.error('Cannot remove all remote videos of %s.', url)
+
+      PodsDB.remove({ url: url }, function (err) {
+        if (err) return callback(err)
+
+        logger.info('%s pod removed.', url)
+        callback(null)
+      })
     })
   }
 
+  function removeVideoToFriends (video) {
+    // To avoid duplicates
+    var id = video.name + video.magnetUri
+    poolRequests.addToPoolRequests(id, 'remove', video)
+  }
+
+  // ---------------------------------------------------------------------------
+
   module.exports = pods
+
+  // ---------------------------------------------------------------------------
+
+  function getForeignPodsList (url, callback) {
+    var path = '/api/' + constants.API_VERSION + '/pods'
+
+    request.get(url + path, function (err, response, body) {
+      if (err) throw err
+      callback(JSON.parse(body))
+    })
+  }
 })()
diff --git a/models/videos.js b/models/videos.js
index 626c55819..5711c5657 100644
--- a/models/videos.js
+++ b/models/videos.js
@@ -11,51 +11,29 @@
   var pods = require('./pods')
   var VideosDB = require('../initializers/database').VideosDB
 
-  var videos = {}
-
   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.info('Seeding %s...', path)
-
-    webtorrent.seed(path, function (torrent) {
-      logger.info('%s seeded (%s).', path, torrent.magnetURI)
-
-      return callback(null, torrent)
-    })
+  var videos = {
+    add: add,
+    addRemotes: addRemotes,
+    get: get,
+    list: list,
+    listOwned: listOwned,
+    remove: remove,
+    removeAllRemotes: removeAllRemotes,
+    removeAllRemotesOf: removeAllRemotesOf,
+    removeRemotes: removeRemotes,
+    search: search,
+    seedAll: seedAll,
+    uploadDir: uploadDir
   }
 
   // ----------- 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.listOwned = function (callback) {
-    // If namePath is not null this is *our* video
-    VideosDB.find({ namePath: { $ne: null } }, function (err, videos_list) {
-      if (err) {
-        logger.error('Cannot get list of the videos.', { error: err })
-        return callback(err)
-      }
+  var uploadDir = __dirname + '/../' + config.get('storage.uploads')
 
-      return callback(null, videos_list)
-    })
-  }
-
-  videos.add = function (data, callback) {
+  function add (data, callback) {
     var video_file = data.video
     var video_data = data.data
 
@@ -89,7 +67,74 @@
     })
   }
 
-  videos.remove = function (id, callback) {
+  // TODO: avoid doublons
+  function addRemotes (videos, callback) {
+    if (callback === undefined) callback = function () {}
+
+    var to_add = []
+
+    async.each(videos, function (video, callback_each) {
+      callback_each = dz(callback_each)
+      logger.debug('Add remote video from pod: %s', video.podUrl)
+
+      var params = {
+        name: video.name,
+        namePath: null,
+        description: video.description,
+        magnetUri: video.magnetUri,
+        podUrl: video.podUrl
+      }
+
+      to_add.push(params)
+
+      callback_each()
+    }, function () {
+      VideosDB.create(to_add, function (err, videos) {
+        if (err) {
+          logger.error('Cannot insert this remote video.', { error: err })
+          return callback(err)
+        }
+
+        return callback(null, videos)
+      })
+    })
+  }
+
+  function get (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)
+    })
+  }
+
+  function list (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)
+    })
+  }
+
+  function listOwned (callback) {
+    // If namePath is not null this is *our* video
+    VideosDB.find({ namePath: { $ne: null } }, function (err, videos_list) {
+      if (err) {
+        logger.error('Cannot get list of the videos.', { error: err })
+        return callback(err)
+      }
+
+      return callback(null, videos_list)
+    })
+  }
+
+  function remove (id, callback) {
     // Maybe the torrent is not seeded, but we catch the error to don't stop the removing process
     function removeTorrent (magnetUri, callback) {
       try {
@@ -122,7 +167,7 @@
             return callback(err)
           }
 
-          fs.unlink(videos.uploadDir + video.namePath, function (err) {
+          fs.unlink(uploadDir + video.namePath, function (err) {
             if (err) {
               logger.error('Cannot remove this video file.', { error: err })
               return callback(err)
@@ -141,8 +186,24 @@
     })
   }
 
+  function removeAllRemotes (callback) {
+    VideosDB.remove({ namePath: null }, function (err) {
+      if (err) return callback(err)
+
+      callback(null)
+    })
+  }
+
+  function removeAllRemotesOf (fromUrl, callback) {
+    VideosDB.remove({ podUrl: fromUrl }, function (err) {
+      if (err) return callback(err)
+
+      callback(null)
+    })
+  }
+
   // Use the magnet Uri because the _id field is not the same on different servers
-  videos.removeRemotes = function (fromUrl, magnetUris, callback) {
+  function removeRemotes (fromUrl, magnetUris, callback) {
     if (callback === undefined) callback = function () {}
 
     VideosDB.find({ magnetUri: { $in: magnetUris } }, function (err, videos) {
@@ -176,68 +237,7 @@
     })
   }
 
-  videos.removeAllRemotes = function (callback) {
-    VideosDB.remove({ namePath: null }, function (err) {
-      if (err) return callback(err)
-
-      callback(null)
-    })
-  }
-
-  videos.removeAllRemotesOf = function (fromUrl, callback) {
-    VideosDB.remove({ podUrl: fromUrl }, function (err) {
-      if (err) return callback(err)
-
-      callback(null)
-    })
-  }
-
-  // { name, magnetUri, podUrl }
-  // TODO: avoid doublons
-  videos.addRemotes = function (videos, callback) {
-    if (callback === undefined) callback = function () {}
-
-    var to_add = []
-
-    async.each(videos, function (video, callback_each) {
-      callback_each = dz(callback_each)
-      logger.debug('Add remote video from pod: %s', video.podUrl)
-
-      var params = {
-        name: video.name,
-        namePath: null,
-        description: video.description,
-        magnetUri: video.magnetUri,
-        podUrl: video.podUrl
-      }
-
-      to_add.push(params)
-
-      callback_each()
-    }, function () {
-      VideosDB.create(to_add, function (err, videos) {
-        if (err) {
-          logger.error('Cannot insert this remote video.', { error: err })
-          return callback(err)
-        }
-
-        return callback(null, videos)
-      })
-    })
-  }
-
-  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) {
+  function search (name, callback) {
     VideosDB.find({ name: new RegExp(name) }, function (err, videos) {
       if (err) {
         logger.error('Cannot search the videos.', { error: err })
@@ -248,7 +248,7 @@
     })
   }
 
-  videos.seedAll = function (callback) {
+  function seedAll (callback) {
     VideosDB.find({ namePath: { $ne: null } }, function (err, videos_list) {
       if (err) {
         logger.error('Cannot get list of the videos to seed.', { error: err })
@@ -256,7 +256,7 @@
       }
 
       async.each(videos_list, function (video, each_callback) {
-        seedVideo(videos.uploadDir + video.namePath, function (err) {
+        seedVideo(uploadDir + video.namePath, function (err) {
           if (err) {
             logger.error('Cannot seed this video.', { error: err })
             return callback(err)
@@ -268,5 +268,19 @@
     })
   }
 
+  // ---------------------------------------------------------------------------
+
   module.exports = videos
+
+  // ---------------------------------------------------------------------------
+
+  function seedVideo (path, callback) {
+    logger.info('Seeding %s...', path)
+
+    webtorrent.seed(path, function (torrent) {
+      logger.info('%s seeded (%s).', path, torrent.magnetURI)
+
+      return callback(null, torrent)
+    })
+  }
 })()