fix: revert deluge 2.x. @ctrl/deluge 1.x will stop support for deluge 1 here

Author: scttcper

package.json

@@ -28,6 +28,7 @@
   },
   "dependencies": {
     "@ctrl/shared-torrent": "^1.3.1",
+    "@ctrl/torrent-file": "^1.0.0",
     "form-data": "^2.3.3",
     "got": "^9.6.0",
     "tough-cookie": "^3.0.1",

src/index.ts

@@ -11,6 +11,7 @@ import {
   TorrentState,
   AddTorrentOptions as NormalizedAddTorrentOptions,
 } from '@ctrl/shared-torrent';
+import { hash } from '@ctrl/torrent-file';
 
 import {
   GetHostsResponse,
@@ -31,8 +32,6 @@ import {
   TorrentStatus,
   Tracker,
   Torrent,
-  StringStatus,
-  AddTorrentResponse,
 } from './types';
 
 const defaults: TorrentSettings = {
@@ -78,11 +77,11 @@ export class Deluge implements TorrentClient {
   }
 
   /**
-   * Connects deluge and returns a list of available methods
+   * Connects deluge
    * @param host index of host to use in result of get hosts
    * @param hostIdx index of host to use in result of get hosts
    */
-  async connect(selectedHost?: string, hostIdx = 0): Promise<ListMethods> {
+  async connect(selectedHost?: string, hostIdx = 0): Promise<DefaultResponse> {
     let host = selectedHost;
     if (!host) {
       const hosts = await this.getHosts();
@@ -93,7 +92,7 @@ export class Deluge implements TorrentClient {
       throw new Error('No hosts found');
     }
 
-    const res = await this.request<ListMethods>('web.connect', [host], true, false);
+    const res = await this.request<DefaultResponse>('web.connect', [host], true, false);
     return res.body;
   }
 
@@ -107,14 +106,8 @@ export class Deluge implements TorrentClient {
    * Other instances may also reconnect. Not really sure why you would want to disconnect
    */
   async disconnect(): Promise<boolean> {
-    const res = await this.request<StringStatus>('web.disconnect', [], true, false);
-    // deluge 1.x returns a boolean and 2.x returns a string
-    if (typeof res.body.result === 'boolean') {
-      return res.body.result;
-    }
-
-    // "Connection was closed cleanly."
-    return res.body.result.includes('closed cleanly');
+    const res = await this.request<BooleanStatus>('web.disconnect', [], true, false);
+    return res.body.result;
   }
 
   /**
@@ -215,7 +208,7 @@ export class Deluge implements TorrentClient {
       headers: form.getHeaders(),
       body: form,
       retry: 0,
-    };
+    }
     // allow proxy agent
     if (this.config.agent) {
       options.agent = this.config.agent;
@@ -229,10 +222,7 @@ export class Deluge implements TorrentClient {
     return JSON.parse(res.body);
   }
 
-  async addTorrent(
-    torrent: string | Buffer,
-    config: Partial<AddTorrentOptions> = {},
-  ): Promise<AddTorrentResponse> {
+  async addTorrent(torrent: string | Buffer, config: Partial<AddTorrentOptions> = {}) {
     const upload = await this.upload(torrent);
     if (!upload.success || !upload.files.length) {
       throw new Error('Failed to upload');
@@ -251,16 +241,11 @@ export class Deluge implements TorrentClient {
       // not passing path by default uses default
       // download_location: '/root/Downloads',
       // move_completed_path: '/root/Downloads',
-      pre_allocate_storage: false,
-      move_completed: false,
-      seed_mode: false,
-      sequential_download: false,
-      super_seeding: false,
       ...config,
     };
-    const res = await this.request<AddTorrentResponse>('web.add_torrents', [[{ path, options }]]);
+    const res = await this.request<BooleanStatus>('web.add_torrents', [[{ path, options }]]);
 
-    if (res.body.result[0][0] === false) {
+    if (res.body.result === false) {
       throw new Error('Failed to add torrent');
     }
 
@@ -280,12 +265,11 @@ export class Deluge implements TorrentClient {
       torrent = Buffer.from(torrent);
     }
 
-    const res = await this.addTorrent(torrent, torrentOptions);
-    const torrentHash = res.result[0][1];
+    const torrentHash = await hash(torrent);
+
+    await this.addTorrent(torrent, torrentOptions);
 
     if (options.label) {
-      // sets the label but it might not set the label right away
-      // sometimes takes a few seconds for label to reflect in results
       await this.setTorrentLabel(torrentHash, options.label);
     }
 
@@ -304,12 +288,7 @@ export class Deluge implements TorrentClient {
       prioritize_first_last_pieces: false,
       // not passing path by default uses default
       // download_location: '/root/Downloads',
-      move_completed: false,
       // move_completed_path: '/root/Downloads',
-      pre_allocate_storage: false,
-      seed_mode: false,
-      sequential_download: false,
-      super_seeding: false,
       ...config,
     };
     const res = await this.request<BooleanStatus>('core.add_torrent_magnet', [magnet, options]);
@@ -412,10 +391,7 @@ export class Deluge implements TorrentClient {
    * get torrent state/status
    * @param additionalFields fields ex - `['label']`
    */
-  async getTorrentStatus(
-    torrentId: string,
-    additionalFields: string[] = [],
-  ): Promise<TorrentStatus> {
+  async getTorrentStatus(torrentId: string, additionalFields: string[] = []): Promise<TorrentStatus> {
     const fields = [
       'total_done',
       'total_payload_download',

src/types.ts

@@ -11,21 +11,10 @@ export interface BooleanStatus extends DefaultResponse {
   result: boolean;
 }
 
-export interface StringStatus extends DefaultResponse {
-  result: string;
-}
-
 export interface ListMethods extends DefaultResponse {
   result: string[];
 }
 
-export interface AddTorrentResponse extends DefaultResponse {
-  /**
-   * tuple of [result, torrent_hash_id]
-   */
-  result: Array<[boolean, string]>
-}
-
 // {"files": ["/tmp/delugeweb-5Q9ttR/tmpL7xhth.torrent"], "success": true}
 /**
  * ex -
@@ -100,12 +89,7 @@ export interface AddTorrentOptions {
   max_upload_slots: number;
   max_upload_speed: number;
   prioritize_first_last_pieces: boolean;
-  move_completed: boolean;
   move_completed_path?: string;
-  pre_allocate_storage: boolean;
-  sequential_download: boolean;
-  seed_mode: boolean;
-  super_seeding: boolean;
 }
 
 export interface TorrentListResponse extends DefaultResponse {

test/index.spec.ts

@@ -7,10 +7,9 @@ import { Deluge } from '../src/index';
 const baseUrl = 'http://localhost:8112';
 const torrentName = 'ubuntu-18.04.1-desktop-amd64.iso';
 const torrentFile = path.join(__dirname, '/ubuntu-18.04.1-desktop-amd64.iso.torrent');
-const torrentHash = 'e84213a794f3ccd890382a54a64ca68b7e925433';
 
 async function setupTorrent(deluge: Deluge) {
-  await deluge.addTorrent(torrentFile, { add_paused: true });
+  await deluge.addTorrent(torrentFile);
   await pWaitFor(
     async () => {
       const r = await deluge.listTorrents();
@@ -34,7 +33,7 @@ describe('Deluge', () => {
     const ids = Object.keys(torrents.result.torrents);
     for (const id of ids) {
       // clean up all torrents
-      await deluge.removeTorrent(id, true);
+      await deluge.removeTorrent(id, false);
     }
   });
   it('should be instantiable', async () => {
@@ -50,15 +49,23 @@ describe('Deluge', () => {
   it('should connect', async () => {
     const deluge = new Deluge({ baseUrl });
     const res = await deluge.connect();
-    // theres a bunch
-    expect(res.result.length).toBeGreaterThan(2);
+    expect(res.result).toBe(null);
   });
   it('should get plugins', async () => {
     const deluge = new Deluge({ baseUrl });
     const res = await deluge.getPlugins();
-    expect(res.result.enabled_plugins.length).toBeGreaterThan(0);
+    expect(res.result.enabled_plugins).toEqual(['Label']);
     expect(res.result.available_plugins).toBeDefined();
-    expect(res.result.available_plugins).toContain('Label');
+    expect(res.result.available_plugins).toEqual([
+      'Extractor',
+      'Execute',
+      'Blocklist',
+      'AutoAdd',
+      'Label',
+      'Notifications',
+      'WebUi',
+      'Scheduler',
+    ]);
   });
   it('should get plugins info', async () => {
     const deluge = new Deluge({ baseUrl });
@@ -113,7 +120,7 @@ describe('Deluge', () => {
     expect(deluge.config.password).toBe(oldPassword);
     deluge.config.password = 'wrongpassword';
     // tslint:disable-next-line no-floating-promises
-    await expect(deluge.changePassword('shouldfail')).rejects.toThrowError();
+    expect(deluge.changePassword('shouldfail')).rejects.toThrowError();
   });
   it('should list methods', async () => {
     const deluge = new Deluge({ baseUrl });
@@ -130,21 +137,18 @@ describe('Deluge', () => {
   it('should add torrent from file path string', async () => {
     const deluge = new Deluge({ baseUrl });
     const res = await deluge.addTorrent(torrentFile);
-    expect(res.result[0][0]).toBe(true);
-    expect(res.result[0][1]).toBe(torrentHash);
+    expect(res.result).toBe(true);
   });
   it('should add torrent from file buffer', async () => {
     const deluge = new Deluge({ baseUrl });
     const res = await deluge.addTorrent(fs.readFileSync(torrentFile));
-    expect(res.result[0][0]).toBe(true);
-    expect(res.result[0][1]).toBe(torrentHash);
+    expect(res.result).toBe(true);
   });
   it('should add torrent from file contents base64', async () => {
     const deluge = new Deluge({ baseUrl });
     const contents = Buffer.from(fs.readFileSync(torrentFile)).toString('base64');
     const res = await deluge.addTorrent(contents);
-    expect(res.result[0][0]).toBe(true);
-    expect(res.result[0][1]).toBe(torrentHash);
+    expect(res.result).toBe(true);
   });
   it('should get torrent status', async () => {
     const deluge = new Deluge({ baseUrl });
@@ -201,13 +205,6 @@ describe('Deluge', () => {
     const key = Object.keys(res.result.torrents)[0];
     await deluge.verifyTorrent(key);
   });
-  it('should add label', async () => {
-    const client = new Deluge({ baseUrl });
-    const list = await setupTorrent(client);
-    const key = Object.keys(list.result.torrents)[0];
-    const res = await client.setTorrentLabel(key, 'swag');
-    expect(res.result).toBe(null);
-  });
   it('should pause/resume torrents', async () => {
     const deluge = new Deluge({ baseUrl });
     const res = await setupTorrent(deluge);
@@ -270,13 +267,12 @@ describe('Deluge', () => {
     const torrent = await client.normalizedAddTorrent(fs.readFileSync(torrentFile), {
       label: 'test',
     });
-    expect(torrent.connectedPeers).toBeGreaterThanOrEqual(0);
+    expect(torrent.connectedPeers).toBe(0);
     expect(torrent.connectedSeeds).toBe(0);
     expect(torrent.downloadSpeed).toBe(0);
     expect(torrent.eta).toBe(0);
-    // expect(torrent.isCompleted).toBe(false);
-    // its setting the label but it takes an unknown number of seconds to save to db
-    // expect(torrent.label).toBe('');
+    expect(torrent.isCompleted).toBe(false);
+    expect(torrent.label).toBe('test');
     expect(torrent.name).toBe(torrentName);
     expect(torrent.progress).toBeGreaterThanOrEqual(0);
     expect(torrent.queuePosition).toBe(1);