[scraper] updates scapers limiter usage

scraper/scrapers/kickass/kickass_api.js

@@ -2,6 +2,7 @@ const cheerio = require('cheerio');
 const needle = require('needle');
 const moment = require('moment');
 const decode = require('magnet-uri');
+const Promises = require('../../lib/promises');
 
 const defaultProxies = [
   'https://katcr.co'
@@ -26,7 +27,7 @@ function torrent(torrentId, config = {}, retries = 2) {
   }
   const proxyList = config.proxyList || defaultProxies;
 
-  return raceFirstSuccessful(proxyList
+  return Promises.first(proxyList
       .map((proxyUrl) => singleRequest(`${proxyUrl}/torrent/${torrentId}`, config)))
       .then((body) => parseTorrentPage(body))
       .then((torrent) => ({ torrentId, ...torrent }))
@@ -41,7 +42,7 @@ function search(keyword, config = {}, retries = 2) {
   const page = config.page || 1;
   const category = config.category;
 
-  return raceFirstSuccessful(proxyList
+  return Promises.first(proxyList
       .map((proxyUrl) => singleRequest(`${proxyUrl}/search/${keyword}/${page}/99/${category}`, 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}/category/${category}/page/${page}`, config)))
       .then((body) => parseTableBody(body))
       .catch((err) => browse(config, retries - 1));
@@ -94,9 +95,12 @@ function parseTableBody(body) {
 
     $('.table > tbody > tr').each((i, element) => {
       const row = $(element);
+      const magnetLink = row.find('a[title="Torrent magnet link"]').attr('href');
       torrents.push({
-        torrentId: row.find('a[class="torrents_table__torrent_title"]').first().attr('href').replace('/torrent/', ''),
         name: row.find('a[class="torrents_table__torrent_title"]').first().children('b').text(),
+        infoHash: decode(magnetLink).infoHash,
+        magnetLink: magnetLink,
+        torrentId: row.find('a[class="torrents_table__torrent_title"]').first().attr('href').replace('/torrent/', ''),
         category: row.find('span[class="torrents_table__upload_info"]').first().children('a').first().attr('href')
             .match(/category\/([^\/]+)/)[1],
         seeders: parseInt(row.find('td[data-title="Seed"]').first().text()),
@@ -167,21 +171,4 @@ function parseSize(sizeText) {
   return Math.floor(parseFloat(sizeText.replace(/[',]/g, '')) * 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/kickass/kickass_scraper.js

@@ -3,15 +3,11 @@ const Bottleneck = require('bottleneck');
 const kickass = require('./kickass_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 = 'KickassTorrents';
-const UNTIL_PAGE = 1;
+const UNTIL_PAGE = 10;
 const TYPE_MAPPING = typeMapping();
 
 const limiter = new Bottleneck({ maxConcurrent: 40 });
@@ -21,33 +17,36 @@ 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 = [
     kickass.Categories.MOVIE,
     kickass.Categories.TV,
     kickass.Categories.ANIME,
   ];
 
-  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) {
+async function scrapeLatestTorrentsForCategory(category, page = 1) {
+  console.log(`Scrapping ${NAME} ${category} category page ${page}`);
   return kickass.browse(({ category, page }))
-      .then(torrents => torrents.length && page < UNTIL_PAGE
-          ? getLatestTorrents(category, page + 1).then(nextTorrents => torrents.concat(nextTorrents))
-          : torrents)
-      .catch(() => []);
+      .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) {
@@ -58,7 +57,7 @@ async function processTorrentRecord(record) {
   const torrentFound = await kickass.torrent(record.torrentId).catch(() => undefined);
 
   if (!torrentFound || !TYPE_MAPPING[torrentFound.category]) {
-    return createSkipTorrentEntry(record);
+    return Promise.resolve('Invalid torrent record');
   }
 
   const torrent = {
@@ -73,7 +72,7 @@ async function processTorrentRecord(record) {
     seeders: torrentFound.seeders,
   };
 
-  return createTorrentEntry(torrent);
+  return createTorrentEntry(torrent).then(() => torrent);
 }
 
 function typeMapping() {