@jesec/flood 0.0.0-master.fc39f18 → 0.0.0-master.fcbe368

package/server/services/diskUsageService.js

@@ -1,155 +0,0 @@
-/**
- * This service is not per rtorrent session, which is why it does not inherit
- * `BaseService` nor have any use of the per user API ie. `getSerivce()`
- */
-const EventEmitter = require('events');
-const util = require('util');
-const execFile = util.promisify(require('child_process').execFile);
-const config = require('../../config');
-const diskUsageServiceEvents = require('../constants/diskUsageServiceEvents');
-
-const PLATFORMS_SUPPORTED = ['darwin', 'linux', 'freebsd', 'win32'];
-const MAX_BUFFER_SIZE = 65536;
-
-const filterMountPoint =
-  config.diskUsageService && config.diskUsageService.watchMountPoints
-    ? // if user has configured watchPartitions filter each line output for given
-      // array
-      (mountpoint) => config.diskUsageService.watchMountPoints.includes(mountpoint)
-    : () => true; // include all mounted file systems by default
-
-const diskUsage = {
-  linux: () =>
-    execFile('df -xsquashfs -xtmpfs -xdevtmpfs | tail -n+2', {
-      shell: true,
-      maxBuffer: MAX_BUFFER_SIZE,
-    }).then(({stdout}) =>
-      stdout
-        .trim()
-        .split('\n')
-        .map((disk) => disk.split(/\s+/))
-        .filter((disk) => filterMountPoint(disk[5]))
-        .map(([_fs, size, used, avail, _pcent, target]) => {
-          return {
-            size: Number.parseInt(size, 10) * 1024,
-            used: Number.parseInt(used, 10) * 1024,
-            avail: Number.parseInt(avail, 10) * 1024,
-            target,
-          };
-        }),
-    ),
-  freebsd: () =>
-    execFile('df | tail -n+2', {
-      shell: true,
-      maxBuffer: MAX_BUFFER_SIZE,
-    }).then(({stdout}) =>
-      stdout
-        .trim()
-        .split('\n')
-        .map((disk) => disk.split(/\s+/))
-        .filter((disk) => filterMountPoint(disk[5]))
-        .map(([_fs, size, used, avail, _pcent, target]) => {
-          return {
-            size: Number.parseInt(size, 10) * 1024,
-            used: Number.parseInt(used, 10) * 1024,
-            avail: Number.parseInt(avail, 10) * 1024,
-            target,
-          };
-        }),
-    ),
-  darwin: () =>
-    execFile('df -kl | tail -n+2', {
-      shell: true,
-      maxBuffer: MAX_BUFFER_SIZE,
-    }).then(({stdout}) =>
-      stdout
-        .trim()
-        .split('\n')
-        .map((disk) => disk.split(/\s+/))
-        .filter((disk) => filterMountPoint(disk[8]))
-        .map(([_fs, size, used, avail, _pcent, _iused, _ifree, _piused, target]) => {
-          return {
-            size: Number.parseInt(size, 10) * 1024,
-            used: Number.parseInt(used, 10) * 1024,
-            avail: Number.parseInt(avail, 10) * 1024,
-            target,
-          };
-        }),
-    ),
-  win32: () =>
-    execFile('wmic logicaldisk', {
-      shell: true,
-      maxBuffer: MAX_BUFFER_SIZE,
-    }).then(({stdout}) =>
-      stdout
-        .trim()
-        .split('\n')
-        .slice(1)
-        .map((disk) => disk.split(/\s+/))
-        .filter((disk) => filterMountPoint(disk[1]))
-        .map((disk) => ({
-          size: disk[14],
-          used: disk[14] - disk[10],
-          avail: disk[10],
-          target: disk[1],
-        })),
-    ),
-};
-
-const INTERVAL_UPDATE = 10000;
-
-class DiskUsageService extends EventEmitter {
-  constructor() {
-    super();
-    this.disks = [];
-    this.tLastChange = 0;
-    this.interval = 0;
-
-    if (!PLATFORMS_SUPPORTED.includes(process.platform)) {
-      console.log(`warning: DiskUsageService is only supported in ${PLATFORMS_SUPPORTED.join()}`);
-      return;
-    }
-
-    // start polling disk usage when the first listener is added
-    this.on('newListener', (event) => {
-      if (
-        this.listenerCount(diskUsageServiceEvents.DISK_USAGE_CHANGE) === 0 &&
-        event === diskUsageServiceEvents.DISK_USAGE_CHANGE
-      ) {
-        this.updateInterval = setInterval(this.updateDisks.bind(this), INTERVAL_UPDATE);
-      }
-    });
-
-    // stop polling disk usage when the last listener is removed
-    this.on('removeListener', (event) => {
-      if (
-        this.listenerCount(diskUsageServiceEvents.DISK_USAGE_CHANGE) === 0 &&
-        event === diskUsageServiceEvents.DISK_USAGE_CHANGE
-      ) {
-        clearInterval(this.updateInterval);
-      }
-    });
-  }
-
-  updateDisks() {
-    if (!PLATFORMS_SUPPORTED.includes(process.platform)) {
-      return Promise.resolve([]);
-    }
-    return diskUsage[process.platform]().then((disks) => {
-      if (disks.length !== this.disks.length || disks.some((d, i) => d.used !== this.disks[i].used)) {
-        this.tLastChange = Date.now();
-        this.disks = disks;
-        this.emit(diskUsageServiceEvents.DISK_USAGE_CHANGE, this.getDiskUsage());
-      }
-    });
-  }
-
-  getDiskUsage() {
-    return {
-      id: this.tLastChange,
-      disks: this.disks,
-    };
-  }
-}
-
-module.exports = new DiskUsageService();

package/server/services/feedService.js

@@ -1,363 +0,0 @@
-const path = require('path');
-const Datastore = require('nedb');
-
-const BaseService = require('./BaseService');
-const client = require('../models/client');
-const config = require('../../config');
-const Feed = require('../models/Feed');
-const regEx = require('../../shared/util/regEx');
-
-// TODO: Allow users to specify which key contains the URLs.
-const getTorrentUrlsFromItem = (feedItem) => {
-  // If we've got an Array of enclosures, we'll iterate over the values and
-  // look for the url key.
-  if (feedItem.enclosures && Array.isArray(feedItem.enclosures)) {
-    return feedItem.enclosures.reduce((urls, enclosure) => {
-      if (enclosure.url) {
-        urls.push(enclosure.url);
-      }
-
-      return urls;
-    }, []);
-  }
-
-  // If we've got a Object of enclosures, use url key
-  if (feedItem.enclosure && feedItem.enclosure.url) {
-    return [feedItem.enclosure.url];
-  }
-
-  // If there are no enclosures, then use the link tag instead
-  if (feedItem.link) {
-    // remove CDATA tags around links
-    const cdata = regEx.cdata.exec(feedItem.link);
-
-    if (cdata && cdata[1]) {
-      return [cdata[1]];
-    }
-
-    return [feedItem.link];
-  }
-
-  return [];
-};
-
-const getItemsMatchingRules = (feedItems, rules, feed) => {
-  return feedItems.reduce((matchedItems, feedItem) => {
-    rules.forEach((rule) => {
-      const isMatched = new RegExp(rule.match, 'gi').test(feedItem[rule.field]);
-      const isExcluded = rule.exclude !== '' && new RegExp(rule.exclude, 'gi').test(feedItem[rule.field]);
-
-      if (isMatched && !isExcluded) {
-        const torrentUrls = getTorrentUrlsFromItem(feedItem);
-        const isAlreadyDownloaded = matchedItems.some((matchedItem) =>
-          torrentUrls.every((url) => matchedItem.urls.includes(url)),
-        );
-
-        if (!isAlreadyDownloaded) {
-          matchedItems.push({
-            urls: torrentUrls,
-            tags: rule.tags,
-            feedID: rule.feedID,
-            feedLabel: feed.label,
-            matchTitle: feedItem.title,
-            ruleID: rule._id,
-            ruleLabel: rule.label,
-            destination: rule.destination,
-            startOnLoad: rule.startOnLoad,
-          });
-        }
-      }
-    });
-
-    return matchedItems;
-  }, []);
-};
-
-const getUrlsFromItems = (feedItems) => {
-  return feedItems.reduce((urls, feedItem) => urls.concat(feedItem.urls), []);
-};
-
-class FeedService extends BaseService {
-  constructor(...serviceConfig) {
-    super(...serviceConfig);
-
-    this.isDBReady = false;
-    this.db = this.loadDatabase();
-
-    this.init();
-  }
-
-  addFeed(feed, callback) {
-    this.addItem('feed', feed, (newFeed) => {
-      this.startNewFeed(newFeed);
-      callback(newFeed);
-    });
-  }
-
-  modifyFeed(id, feedToModify, callback) {
-    const modifiedFeed = this.feeds.find((feed) => feed.options._id === id);
-    modifiedFeed.stopReader();
-    modifiedFeed.modify(feedToModify);
-    this.modifyItem(id, feedToModify, (err) => {
-      callback(err);
-    });
-  }
-
-  addItem(type, item, callback) {
-    if (!this.isDBReady) return;
-
-    this.db.insert(Object.assign(item, {type}), (err, newDoc) => {
-      if (err) {
-        callback(null, err);
-        return;
-      }
-
-      callback(newDoc);
-    });
-  }
-
-  modifyItem(id, newItem, callback) {
-    if (!this.isDBReady) {
-      return;
-    }
-
-    this.db.update({_id: id}, {$set: newItem}, {}, (err) => {
-      if (err) {
-        callback(null, err);
-        return;
-      }
-
-      callback(null);
-    });
-  }
-
-  addRule(rule, callback) {
-    this.addItem('rule', rule, (newRule, error) => {
-      if (error) {
-        callback(null, error);
-        return;
-      }
-
-      callback(newRule);
-
-      if (this.rules[newRule.feedID] == null) {
-        this.rules[newRule.feedID] = [];
-      }
-
-      this.rules[newRule.feedID].push(newRule);
-
-      const associatedFeed = this.feeds.find((feed) => feed.options._id === newRule.feedID);
-
-      if (associatedFeed) {
-        this.handleNewItems({
-          feed: associatedFeed.options,
-          items: associatedFeed.getItems(),
-        });
-      }
-    });
-  }
-
-  getAll(callback) {
-    this.db.find({}, (err, docs) => {
-      if (err) {
-        callback(null, err);
-        return;
-      }
-
-      callback(
-        docs.reduce((memo, item) => {
-          const type = `${item.type}s`;
-
-          if (memo[type] == null) {
-            memo[type] = [];
-          }
-
-          memo[type].push(item);
-
-          return memo;
-        }, {}),
-      );
-    });
-  }
-
-  getFeeds(query, callback) {
-    this.queryItem('feed', query, callback);
-  }
-
-  getItems(query, callback) {
-    const selectedFeed = this.feeds.find((feed) => feed.options._id === query.id);
-
-    if (selectedFeed) {
-      const items = selectedFeed.getItems();
-
-      if (query.search) {
-        callback(items.filter((item) => item.title.toLowerCase().indexOf(query.search.toLowerCase()) !== -1));
-      } else {
-        callback(items);
-      }
-    } else {
-      callback(null);
-    }
-  }
-
-  getPreviouslyMatchedUrls() {
-    return new Promise((resolve, reject) => {
-      this.db.find({type: 'matchedTorrents'}, (err, docs) => {
-        if (err) {
-          reject(err);
-        }
-
-        resolve(docs.reduce((matchedUrls, doc) => matchedUrls.concat(doc.urls), []));
-      });
-    });
-  }
-
-  getRules(query, callback) {
-    this.queryItem('rule', query, callback);
-  }
-
-  handleNewItems({items: feedItems, feed}) {
-    this.getPreviouslyMatchedUrls()
-      .then((previouslyMatchedUrls) => {
-        const applicableRules = this.rules[feed._id];
-        if (!applicableRules) return;
-
-        const itemsMatchingRules = getItemsMatchingRules(feedItems, applicableRules, feed);
-        const itemsToDownload = itemsMatchingRules.filter((item) =>
-          item.urls.some((url) => !previouslyMatchedUrls.includes(url)),
-        );
-
-        const lastAddUrlCallback = () => {
-          const urlsToAdd = getUrlsFromItems(itemsToDownload);
-
-          this.db.update({type: 'matchedTorrents'}, {$push: {urls: {$each: urlsToAdd}}}, {upsert: true});
-
-          this.services.notificationService.addNotification(
-            itemsToDownload.map((item) => ({
-              id: 'notification.feed.downloaded.torrent',
-              data: {
-                feedLabel: item.feedLabel,
-                ruleLabel: item.ruleLabel,
-                title: item.matchTitle,
-              },
-            })),
-          );
-          this.services.torrentService.fetchTorrentList();
-        };
-
-        itemsToDownload.forEach((item, index) => {
-          client.addUrls(
-            this.user,
-            this.services,
-            {
-              urls: item.urls,
-              destination: item.destination,
-              start: item.startOnLoad,
-              tags: item.tags,
-            },
-            () => {
-              if (index === itemsToDownload.length - 1) {
-                lastAddUrlCallback();
-              }
-
-              this.db.update({_id: item.ruleID}, {$inc: {count: 1}}, {upsert: true});
-            },
-          );
-        });
-      })
-      .catch(console.error);
-  }
-
-  init() {
-    this.feeds = [];
-    this.rules = {};
-    this.db.find({}, (err, docs) => {
-      if (err) {
-        return;
-      }
-
-      // Create two arrays, one for feeds and one for rules.
-      const feedsSummary = docs.reduce(
-        (accumulator, doc) => {
-          if (doc.type === 'feed' || doc.type === 'rule') {
-            accumulator[`${doc.type}s`].push(doc);
-          }
-
-          return accumulator;
-        },
-        {feeds: [], rules: []},
-      );
-
-      // Add all download rules to the local state.
-      feedsSummary.rules.forEach((rule) => {
-        if (this.rules[rule.feedID] == null) {
-          this.rules[rule.feedID] = [];
-        }
-
-        this.rules[rule.feedID].push(rule);
-      });
-
-      // Initiate all feeds.
-      feedsSummary.feeds.forEach((feed) => {
-        this.startNewFeed(feed);
-      });
-    });
-  }
-
-  loadDatabase() {
-    if (this.isDBReady) return;
-
-    const db = new Datastore({
-      autoload: true,
-      filename: path.join(config.dbPath, this.user._id, 'settings', 'feeds.db'),
-    });
-    this.isDBReady = true;
-    return db;
-  }
-
-  queryItem(type, query, callback) {
-    query = query || {};
-
-    this.db.find(Object.assign(query, {type}), (err, docs) => {
-      if (err) {
-        callback(null, err);
-        return;
-      }
-
-      callback(docs);
-    });
-  }
-
-  removeItem(id, callback) {
-    let indexToRemove = -1;
-    const itemToRemove = this.feeds.find((feed, index) => {
-      if (feed.options._id === id) {
-        indexToRemove = index;
-        return true;
-      }
-
-      return false;
-    });
-
-    if (itemToRemove != null) {
-      itemToRemove.stopReader();
-      this.feeds.splice(indexToRemove, 1);
-    }
-
-    this.db.remove({_id: id}, {}, (err, docs) => {
-      if (err) {
-        callback(null, err);
-        return;
-      }
-
-      callback(docs);
-    });
-  }
-
-  startNewFeed(feedConfig) {
-    feedConfig.onNewItems = this.handleNewItems.bind(this);
-    this.feeds.push(new Feed(feedConfig));
-  }
-}
-
-module.exports = FeedService;