@jesec/flood 0.0.0-master.485bb1f → 0.0.0-master.4867480

package/dist/server/services/diskUsageService.js

@@ -1,133 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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. `getService()`
- */
-const events_1 = __importDefault(require("events"));
-const child_process_1 = require("child_process");
-const util_1 = __importDefault(require("util"));
-const config_1 = __importDefault(require("../../config"));
-const diskUsageServiceEvents_1 = __importDefault(require("../constants/diskUsageServiceEvents"));
-const execFileAsync = util_1.default.promisify(child_process_1.execFile);
-const PLATFORMS_SUPPORTED = ['darwin', 'linux', 'freebsd', 'win32'];
-const MAX_BUFFER_SIZE = 65536;
-const filterMountPoint = config_1.default.diskUsageService && config_1.default.diskUsageService.watchMountPoints
-    ? // if user has configured watchPartitions filter each line output for given
-        // array
-        (mountpoint) => config_1.default.diskUsageService.watchMountPoints.includes(mountpoint)
-    : () => true; // include all mounted file systems by default
-const diskUsage = {
-    linux: () => execFileAsync('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: () => execFileAsync('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: () => execFileAsync('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: () => execFileAsync('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 events_1.default {
-    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_1.default.DISK_USAGE_CHANGE) === 0 &&
-                event === diskUsageServiceEvents_1.default.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_1.default.DISK_USAGE_CHANGE) === 0 &&
-                event === diskUsageServiceEvents_1.default.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_1.default.DISK_USAGE_CHANGE, this.getDiskUsage());
-            }
-        });
-    }
-    getDiskUsage() {
-        return {
-            id: this.tLastChange,
-            disks: this.disks,
-        };
-    }
-}
-exports.default = new DiskUsageService();

package/dist/server/services/feedService.js

@@ -1,290 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const nedb_1 = __importDefault(require("nedb"));
-const BaseService_1 = __importDefault(require("./BaseService"));
-const client_1 = __importDefault(require("../models/client"));
-const config_1 = __importDefault(require("../../config"));
-const Feed_1 = __importDefault(require("../models/Feed"));
-const regEx_1 = __importDefault(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_1.default.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_1.default {
-    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_1.default.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 nedb_1.default({
-            autoload: true,
-            filename: path_1.default.join(config_1.default.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_1.default(feedConfig));
-    }
-}
-exports.default = FeedService;

package/dist/server/services/historyService.js

@@ -1,181 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const BaseService_1 = __importDefault(require("./BaseService"));
-const config_1 = __importDefault(require("../../config"));
-const HistoryEra_1 = __importDefault(require("../models/HistoryEra"));
-const historyServiceEvents_1 = __importDefault(require("../constants/historyServiceEvents"));
-const historySnapshotTypes_1 = __importDefault(require("../../shared/constants/historySnapshotTypes"));
-const methodCallUtil_1 = __importDefault(require("../util/methodCallUtil"));
-const objectUtil_1 = __importDefault(require("../../shared/util/objectUtil"));
-const transferSummaryPropMap_1 = __importDefault(require("../constants/transferSummaryPropMap"));
-const transferSummaryMethodCallConfig = methodCallUtil_1.default.getMethodCallConfigFromPropMap(transferSummaryPropMap_1.default);
-const processData = (opts, callback, data, error) => {
-    if (error) {
-        callback(null, error);
-        return;
-    }
-    data = data.slice(data.length - config_1.default.maxHistoryStates);
-    callback(data.reduce((accumulator, snapshot) => {
-        accumulator.download.push(snapshot.dn);
-        accumulator.upload.push(snapshot.up);
-        accumulator.timestamps.push(snapshot.ts);
-        return accumulator;
-    }, { upload: [], download: [], timestamps: [] }));
-};
-class HistoryService extends BaseService_1.default {
-    constructor(...serviceConfig) {
-        super(...serviceConfig);
-        this.errorCount = 0;
-        this.lastSnapshots = {};
-        this.pollTimeout = null;
-        this.transferSummary = {};
-        this.fetchCurrentTransferSummary = this.fetchCurrentTransferSummary.bind(this);
-        this.handleFetchTransferSummaryError = this.handleFetchTransferSummaryError.bind(this);
-        this.handleFetchTransferSummarySuccess = this.handleFetchTransferSummarySuccess.bind(this);
-        this.yearSnapshot = new HistoryEra_1.default(this.user, {
-            interval: 1000 * 60 * 60 * 24 * 7,
-            maxTime: 0,
-            name: 'yearSnapshot',
-        });
-        this.monthSnapshot = new HistoryEra_1.default(this.user, {
-            interval: 1000 * 60 * 60 * 12,
-            maxTime: 1000 * 60 * 60 * 24 * 365,
-            name: 'monthSnapshot',
-            nextEraUpdateInterval: 1000 * 60 * 60 * 24 * 7,
-            nextEra: this.yearSnapshot,
-        });
-        this.weekSnapshot = new HistoryEra_1.default(this.user, {
-            interval: 1000 * 60 * 60 * 4,
-            maxTime: 1000 * 60 * 60 * 24 * 7 * 24,
-            name: 'weekSnapshot',
-            nextEraUpdateInterval: 1000 * 60 * 60 * 12,
-            nextEra: this.monthSnapshot,
-        });
-        this.daySnapshot = new HistoryEra_1.default(this.user, {
-            interval: 1000 * 60 * 60,
-            maxTime: 1000 * 60 * 60 * 24 * 30,
-            name: 'daySnapshot',
-            nextEraUpdateInterval: 1000 * 60 * 60 * 4,
-            nextEra: this.weekSnapshot,
-        });
-        this.hourSnapshot = new HistoryEra_1.default(this.user, {
-            interval: 1000 * 60 * 15,
-            maxTime: 1000 * 60 * 60 * 24,
-            name: 'hourSnapshot',
-            nextEraUpdateInterval: 1000 * 60 * 60,
-            nextEra: this.daySnapshot,
-        });
-        this.thirtyMinSnapshot = new HistoryEra_1.default(this.user, {
-            interval: 1000 * 20,
-            maxTime: 1000 * 60 * 30,
-            name: 'thirtyMinSnapshot',
-            nextEraUpdateInterval: 1000 * 60 * 15,
-            nextEra: this.hourSnapshot,
-        });
-        this.fiveMinSnapshot = new HistoryEra_1.default(this.user, {
-            interval: 1000 * 5,
-            maxTime: 1000 * 60 * 5,
-            name: 'fiveMinSnapshot',
-            nextEraUpdateInterval: 1000 * 20,
-            nextEra: this.thirtyMinSnapshot,
-        });
-        this.fetchCurrentTransferSummary();
-    }
-    checkSnapshotDiffs() {
-        Object.keys(historySnapshotTypes_1.default).forEach((snapshotType) => {
-            this.getHistory({ snapshot: historySnapshotTypes_1.default[snapshotType] }, (nextSnapshot, error) => {
-                if (error) {
-                    return;
-                }
-                const lastSnapshot = this.lastSnapshots[snapshotType] || {};
-                const { timestamps = [] } = lastSnapshot;
-                const nextLastTimestamp = timestamps[timestamps.length - 1];
-                const prevLastTimestamp = nextSnapshot.timestamps[nextSnapshot.timestamps.length - 1];
-                if (nextLastTimestamp !== prevLastTimestamp) {
-                    this.emit(historyServiceEvents_1.default[`${snapshotType}_SNAPSHOT_FULL_UPDATE`], {
-                        id: nextLastTimestamp,
-                        data: nextSnapshot,
-                    });
-                }
-                this.lastSnapshots[snapshotType] = nextSnapshot;
-            });
-        });
-    }
-    deferFetchTransferSummary(interval = config_1.default.torrentClientPollInterval || 2000) {
-        this.pollTimeout = setTimeout(this.fetchCurrentTransferSummary, interval);
-    }
-    destroy() {
-        clearTimeout(this.pollTimeout);
-    }
-    fetchCurrentTransferSummary() {
-        if (this.pollTimeout != null) {
-            clearTimeout(this.pollTimeout);
-        }
-        this.services.clientGatewayService
-            .fetchTransferSummary(transferSummaryMethodCallConfig)
-            .then(this.handleFetchTransferSummarySuccess.bind(this))
-            .catch(this.handleFetchTransferSummaryError.bind(this));
-    }
-    getTransferSummary() {
-        return {
-            id: Date.now(),
-            transferSummary: this.transferSummary,
-        };
-    }
-    getHistory(opts = {}, callback) {
-        const historyCallback = processData.bind(this, opts, callback);
-        if (opts.snapshot === historySnapshotTypes_1.default.FIVE_MINUTE) {
-            this.fiveMinSnapshot.getData(opts, historyCallback);
-        }
-        else if (opts.snapshot === historySnapshotTypes_1.default.THIRTY_MINUTE) {
-            this.thirtyMinSnapshot.getData(opts, historyCallback);
-        }
-        else if (opts.snapshot === historySnapshotTypes_1.default.HOUR) {
-            this.hourSnapshot.getData(opts, historyCallback);
-        }
-        else if (opts.snapshot === historySnapshotTypes_1.default.DAY) {
-            this.daySnapshot.getData(opts, historyCallback);
-        }
-        else if (opts.snapshot === historySnapshotTypes_1.default.WEEK) {
-            this.weekSnapshot.getData(opts, historyCallback);
-        }
-        else if (opts.snapshot === historySnapshotTypes_1.default.MONTH) {
-            this.monthSnapshot.getData(opts, historyCallback);
-        }
-        else if (opts.snapshot === historySnapshotTypes_1.default.YEAR) {
-            this.yearSnapshot.getData(opts, historyCallback);
-        }
-    }
-    handleFetchTransferSummarySuccess(nextTransferSummary) {
-        const summaryDiff = objectUtil_1.default.getDiff(this.transferSummary, nextTransferSummary);
-        if (summaryDiff.length > 0) {
-            this.emit(historyServiceEvents_1.default.TRANSFER_SUMMARY_DIFF_CHANGE, {
-                diff: summaryDiff,
-                id: Date.now(),
-            });
-        }
-        this.errorCount = 0;
-        this.transferSummary = nextTransferSummary;
-        this.fiveMinSnapshot.addData({
-            upload: nextTransferSummary.upRate,
-            download: nextTransferSummary.downRate,
-        });
-        this.checkSnapshotDiffs();
-        this.deferFetchTransferSummary();
-        this.emit(historyServiceEvents_1.default.FETCH_TRANSFER_SUMMARY_SUCCESS);
-    }
-    handleFetchTransferSummaryError() {
-        let nextInterval = config_1.default.torrentClientPollInterval || 2000;
-        // If more than consecutive errors have occurred, then we delay the next
-        // request.
-        if (++this.errorCount >= 3) {
-            nextInterval = Math.max(nextInterval + (this.errorCount * nextInterval) / 4, 1000 * 60);
-        }
-        this.deferFetchTransferSummary(nextInterval);
-        this.emit(historyServiceEvents_1.default.FETCH_TRANSFER_SUMMARY_ERROR);
-    }
-}
-exports.default = HistoryService;