[scraper] updates scapers limiter usage

scraper/scrapers/1337x/1337x_api.js

@@ -2,6 +2,7 @@ const cheerio = require('cheerio');
 const needle = require('needle');
 const Sugar = require('sugar-date');
 const decode = require('magnet-uri');
+const Promises = require('../../lib/promises');
 
 const defaultProxies = [
   'https://1337x.to'
@@ -27,7 +28,7 @@ function torrent(torrentId, config = {}, retries = 2) {
   const proxyList = config.proxyList || defaultProxies;
   const slug = torrentId.startsWith('/torrent/') ? torrentId.replace('/torrent/', '') : torrentId;
 
-  return raceFirstSuccessful(proxyList
+  return Promises.first(proxyList
       .map((proxyUrl) => singleRequest(`${proxyUrl}/torrent/${slug}`, config)))
       .then((body) => parseTorrentPage(body))
       .then((torrent) => ({ torrentId: slug, ...torrent }))
@@ -41,7 +42,7 @@ function search(keyword, config = {}, retries = 2) {
   const proxyList = config.proxyList || defaultProxies;
   const page = config.page || 1;
 
-  return raceFirstSuccessful(proxyList
+  return Promises.first(proxyList
       .map((proxyUrl) => singleRequest(`${proxyUrl}/search/${keyword}/${page}/`, config)))
       .then((body) => parseTableBody(body))
       .catch((err) => search(keyword, config, retries - 1));
@@ -55,7 +56,7 @@ function browse(config = {}, retries = 2) {
   const page = config.page || 1;
   const category = config.category;
 
-  return raceFirstSuccessful(proxyList
+  return Promises.first(proxyList
       .map((proxyUrl) => singleRequest(`${proxyUrl}/cat/${category}/${page}/`, config)))
       .then((body) => parseTableBody(body))
       .catch((err) => browse(config, retries - 1));
@@ -154,21 +155,4 @@ function parseSize(sizeText) {
   return Math.floor(parseFloat(sizeText) * scale);
 }
 
-function raceFirstSuccessful(promises) {
-  return Promise.all(promises.map((p) => {
-    // If a request fails, count that as a resolution so it will keep
-    // waiting for other possible successes. If a request succeeds,
-    // treat it as a rejection so Promise.all immediately bails out.
-    return p.then(
-        (val) => Promise.reject(val),
-        (err) => Promise.resolve(err)
-    );
-  })).then(
-      // If '.all' resolved, we've just got an array of errors.
-      (errors) => Promise.reject(errors),
-      // If '.all' rejected, we've got the result we wanted.
-      (val) => Promise.resolve(val)
-  );
-}
-
 module.exports = { torrent, search, browse, Categories };

scraper/scrapers/1337x/1337x_scraper.js

@@ -3,15 +3,11 @@ const Bottleneck = require('bottleneck');
 const leetx = require('./1337x_api');
 const { Type } = require('../../lib/types');
 const repository = require('../../lib/repository');
-const {
-  createTorrentEntry,
-  createSkipTorrentEntry,
-  getStoredTorrentEntry,
-  updateTorrentSeeders
-} = require('../../lib/torrentEntries');
+const Promises = require('../../lib/promises');
+const { createTorrentEntry, getStoredTorrentEntry, updateTorrentSeeders } = require('../../lib/torrentEntries');
 
 const NAME = '1337x';
-const UNTIL_PAGE = 1;
+const UNTIL_PAGE = 10;
 const TYPE_MAPPING = typeMapping();
 
 const limiter = new Bottleneck({ maxConcurrent: 40 });
@@ -21,17 +17,15 @@ async function scrape() {
   const lastScrape = await repository.getProvider({ name: NAME });
   console.log(`[${scrapeStart}] starting ${NAME} scrape...`);
 
-  const latestTorrents = await getLatestTorrents();
-  return Promise.all(latestTorrents.map(torrent => limiter.schedule(() => processTorrentRecord(torrent))))
+  return scrapeLatestTorrents()
       .then(() => {
         lastScrape.lastScraped = scrapeStart;
-        lastScrape.lastScrapedId = latestTorrents.length && latestTorrents[latestTorrents.length - 1].torrentId;
         return repository.updateProvider(lastScrape);
       })
       .then(() => console.log(`[${moment()}] finished ${NAME} scrape`));
 }
 
-async function getLatestTorrents() {
+async function scrapeLatestTorrents() {
   const allowedCategories = [
     leetx.Categories.MOVIE,
     leetx.Categories.TV,
@@ -39,32 +33,36 @@ async function getLatestTorrents() {
     leetx.Categories.DOCUMENTARIES
   ];
 
-  return Promise.all(allowedCategories.map(category => getLatestTorrentsForCategory(category)))
+  return Promises.sequence(allowedCategories.map(category => () => scrapeLatestTorrentsForCategory(category)))
       .then(entries => entries.reduce((a, b) => a.concat(b), []));
 }
 
-async function getLatestTorrentsForCategory(category, page = 1) {
-  return leetx.browse(({ category: category, page: page }))
-      .then(torrents => torrents.length && page < UNTIL_PAGE
-          ? getLatestTorrents(category, page + 1).then(nextTorrents => torrents.concat(nextTorrents))
-          : torrents)
-      .catch(() => []);
+async function scrapeLatestTorrentsForCategory(category, page = 1) {
+  console.log(`Scrapping ${NAME} ${category} category page ${page}`);
+  return leetx.browse(({ category, page }))
+      .then(torrents => Promise.all(torrents.map(torrent => limiter.schedule(() => processTorrentRecord(torrent)))))
+      .then(resolved => resolved.length > 0 && page < UNTIL_PAGE
+          ? scrapeLatestTorrentsForCategory(category, page + 1)
+          : Promise.resolve())
+      .catch(error => {
+        console.warn(`Failed ${NAME} scrapping for [${page}] ${category} due: `, error);
+        return Promise.resolve();
+      });
 }
 
 async function processTorrentRecord(record) {
-  if (await getStoredTorrentEntry(record)) {
-    return updateTorrentSeeders(record);
-  }
-
   const torrentFound = await leetx.torrent(record.torrentId).catch(() => undefined);
 
   if (!torrentFound || !TYPE_MAPPING[torrentFound.category]) {
-    return createSkipTorrentEntry(record);
+    return Promise.resolve('Invalid torrent record');
   }
   if (isNaN(torrentFound.uploadDate)) {
     console.warn(`Incorrect upload date for [${torrentFound.infoHash}] ${torrentFound.name}`);
     return;
   }
+  if (await getStoredTorrentEntry(record)) {
+    return updateTorrentSeeders(record);
+  }
 
   const torrent = {
     infoHash: torrentFound.infoHash,