Port xbmc4lyfe batch 3 (issues #97–#150)

Cargo.toml

@@ -88,9 +88,9 @@ feed-rs = "2"
 unicode-normalization = "0.1"
 
 # Shared NZB crates
-nzb-web = { version = "0.4.23", path = "crates/nzb-web", features = ["groups-db"] }
+nzb-web = { version = "0.4.24", path = "crates/nzb-web", features = ["groups-db"] }
 nzb-nntp = { version = "0.2.24", path = "crates/nzb-nntp" }
-nzb-core = { version = "0.2.18", path = "crates/nzb-core", features = ["groups-db"] }
+nzb-core = { version = "0.2.19", path = "crates/nzb-core", features = ["groups-db"] }
 nzb-decode = { version = "0.1.5", path = "crates/nzb-decode" }
 nzb-news = { version = "0.1.14", path = "crates/nzb-news" }
 nzb-dispatch = { version = "0.2.8", path = "crates/nzb-dispatch" }

README.md

@@ -205,14 +205,26 @@ curl -X POST http://localhost:9090/api/queue/add-url \
   -H "Content-Type: application/json" \
   -d '{"url": "https://example.com/file.nzb", "category": "movies"}'
 
-# Upload NZB file
+# Upload NZB file (optional fields: category/cat, priority 0-3,
+# name/nzbname; each may also be passed as a query parameter, and a form
+# field wins over the query)
 curl -X POST http://localhost:9090/api/queue/add \
-  -F "file=@/path/to/file.nzb" -F "category=tv"
+  -F "file=@/path/to/file.nzb" -F "category=tv" -F "priority=2"
+
+# Upload an NZB with an archive password (multipart `password` field;
+# `add-url` takes a JSON `password`)
+curl -X POST http://localhost:9090/api/queue/add \
+  -F "file=@/path/to/file.nzb" -F "password=secret"
 
 # Check status
 curl http://localhost:9090/api/status
 ```
 
+Job names follow SABnzbd's inline-password convention on both APIs: a name
+or NZB file name of the form `Name{{password}}` or `Name/password` sets the
+job password and is queued as `Name`. An explicit `password` wins over the
+inline one, which wins over a password embedded in the NZB.
+
 The *arr-compatible API is served at `/sabnzbd/api`.
 
 ---

apps/rustnzb/config.example.toml

@@ -6,20 +6,33 @@ incomplete_dir = "/downloads/incomplete"
 complete_dir = "/downloads/complete"
 data_dir = "/data"
 speed_limit_bps = 0  # 0 = unlimited
-cache_size = 524288000  # 500 MB
+cache_size = 524288000  # 500 MB; the API accepts 16 MiB to 64 GiB
+# Log level: trace, debug, info, warn, error, or off. A full filter such as
+# "info,nzb_nntp=debug" is also accepted. Precedence, highest first:
+#   RUST_LOG env (full filter override) > --log-level CLI flag >
+#   RUSTNZB_LOG_LEVEL env > this setting > "info".
+# An invalid value logs a warning and falls back to "info". Applied at start.
 log_level = "info"
+# max_active_downloads = 1  # 0 = unlimited; the API accepts at most 100
 # log_file = "data/rustnzb.log"
 # history_retention = 100  # Number of NZBs to keep in history (omit or 0 = keep all)
+max_active_downloads = 1  # NZBs downloading simultaneously (0 = unlimited)
 # auto_sort_remaining_pct = false  # Keep queued items ordered by remaining work
 # rss_downloaded_item_expiry_days = 30  # Remove downloaded RSS records after this many days
 # Independent post-processing jobs overlap downloads. Separate repair and
 # extraction gates allow those stages to overlap safely across different jobs.
-# These limits are applied at process start.
+# These limits are applied at process start. The API accepts 0..=64 per
+# limit (0 is raised to 1).
 max_post_processing_jobs = 2
 max_repair_workers = 1
 max_extract_workers = 1
 direct_unpack = true  # Extract RAR volumes while downloading when unrar is available
-max_nested_archive_depth = 5  # 0=outer archive only; protects against unbounded nesting
+max_nested_archive_depth = 5  # 0=outer archive only; protects against unbounded nesting (API: 0-10)
+# The download-health settings below are applied at process start.
+# abort_hopeless = true          # edited via /api/config/disk-guards
+# early_failure_check = true     # abort dead NZBs after the first articles
+# required_completion_pct = 100.2  # 100.0-200.0; >100 reserves a PAR2 repair margin
+# article_timeout_secs = 30      # 0 = no timeout; the API accepts at most 3600
 # Post-processing hooks run without a shell, with a bounded timeout and output capture.
 # scripts_dir = "/data/scripts"
 # script_success = "on-success.sh"

apps/rustnzb/frontend/src/app/app.spec.ts

@@ -23,6 +23,7 @@ function makeApp(postResult = new Subject<unknown>()) {
     navigate: vi.fn(() => Promise.resolve(true)),
   };
   const pauseState = new PauseStateService();
+  const snack = { open: vi.fn() };
   const app = new App(
     api as never,
     auth as never,
@@ -31,8 +32,9 @@ function makeApp(postResult = new Subject<unknown>()) {
     {} as never,
     {} as never,
     pauseState,
+    snack as never,
   );
-  return { app, api, pauseState, postResult };
+  return { app, api, pauseState, postResult, snack };
 }
 
 describe('App global pause control', () => {
@@ -46,13 +48,16 @@ describe('App global pause control', () => {
   });
 
   it('rolls back the shared state if the global request fails', () => {
-    const { app, pauseState, postResult } = makeApp();
+    const { app, pauseState, postResult, snack } = makeApp();
     vi.spyOn(app, 'pollStatus').mockImplementation(() => {});
 
     app.togglePause();
     postResult.error(new Error('request failed'));
 
     expect(pauseState.paused()).toBe(false);
+    expect(snack.open).toHaveBeenCalledWith('Failed to pause downloads', 'Close', {
+      duration: 5000,
+    });
   });
 });
 

apps/rustnzb/frontend/src/app/app.ts

@@ -21,6 +21,8 @@ import { WidthModeService } from './core/services/width-mode.service';
 import { PauseStateService } from './core/services/pause-state.service';
 import { ThemeService } from './core/services/theme.service';
 import { IconComponent } from './shared/icon.component';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { showHttpError } from './core/http/http-error';
 
 export function isDemoPath(pathname: string): boolean {
   return pathname === '/demo' || pathname.startsWith('/demo/');
@@ -451,6 +453,7 @@ export class App implements OnInit, OnDestroy {
     public widthMode: WidthModeService,
     readonly theme: ThemeService,
     pauseState: PauseStateService,
+    private snack: MatSnackBar,
   ) {
     this.paused = pauseState.paused;
     this.authenticated = authService.authenticated;
@@ -509,9 +512,14 @@ export class App implements OnInit, OnDestroy {
     this.paused.set(!wasPaused);
     this.api.post(action).subscribe({
       next: () => this.pollStatus(),
-      error: () => {
+      error: (err) => {
         this.paused.set(wasPaused);
         this.pollStatus();
+        showHttpError(
+          this.snack,
+          err,
+          wasPaused ? 'Failed to resume downloads' : 'Failed to pause downloads',
+        );
       },
     });
     this.pauseMenuOpen = false;
@@ -524,7 +532,10 @@ export class App implements OnInit, OnDestroy {
   }
 
   pauseFor(secs: number): void {
-    this.api.post(`/queue/pause-for?duration_secs=${secs}`).subscribe(() => this.pollStatus());
+    this.api.post(`/queue/pause-for?duration_secs=${secs}`).subscribe({
+      next: () => this.pollStatus(),
+      error: (err) => showHttpError(this.snack, err, 'Failed to pause downloads'),
+    });
     this.pauseMenuOpen = false;
   }
 

apps/rustnzb/frontend/src/app/core/http/http-error.spec.ts

@@ -0,0 +1,82 @@
+import '@angular/compiler';
+
+import { HttpErrorResponse } from '@angular/common/http';
+import { describe, expect, it, vi } from 'vitest';
+
+import { httpErrorDetail, httpErrorMessage, isAuthHandledError, showHttpError } from './http-error';
+
+function httpError(status: number, error: unknown): HttpErrorResponse {
+  return new HttpErrorResponse({ status, error, url: '/api/x' });
+}
+
+describe('httpErrorMessage', () => {
+  it('prefers the central human_readable field', () => {
+    const err = httpError(400, {
+      error_kind: 'bad_request',
+      human_readable: 'Feed URL rejected: URL targets a private/reserved address',
+      status: 400,
+    });
+    expect(httpErrorMessage(err, 'Failed to save feed')).toBe(
+      'Failed to save feed: Feed URL rejected: URL targets a private/reserved address',
+    );
+  });
+
+  it('falls back to the legacy error and message fields', () => {
+    expect(httpErrorMessage(httpError(400, { status: false, error: 'No job ID' }), 'Failed')).toBe(
+      'Failed: No job ID',
+    );
+    expect(httpErrorMessage(httpError(422, { message: 'Bad NZB' }), 'Failed')).toBe(
+      'Failed: Bad NZB',
+    );
+  });
+
+  it('parses JSON bodies delivered as text and accepts short plain-text bodies', () => {
+    expect(
+      httpErrorMessage(httpError(400, '{"human_readable":"Invalid regex"}'), 'Failed to save rule'),
+    ).toBe('Failed to save rule: Invalid regex');
+    expect(httpErrorMessage(httpError(415, 'Expected JSON content type'), 'Failed')).toBe(
+      'Failed: Expected JSON content type',
+    );
+  });
+
+  it('uses the fallback when there is no usable server message', () => {
+    expect(httpErrorMessage(httpError(500, null), 'Failed to save')).toBe('Failed to save');
+    expect(
+      httpErrorMessage(httpError(502, '<html><body>Bad gateway</body></html>'), 'Failed'),
+    ).toBe('Failed');
+    expect(httpErrorMessage(httpError(400, { human_readable: '   ' }), 'Failed')).toBe('Failed');
+    expect(httpErrorMessage(new Error('boom'), 'Failed')).toBe('Failed');
+    expect(httpErrorMessage(undefined, 'Failed')).toBe('Failed');
+  });
+
+  it('does not repeat the fallback when the server message already is it', () => {
+    expect(httpErrorMessage(httpError(400, { error: 'Failed' }), 'Failed')).toBe('Failed');
+  });
+});
+
+describe('httpErrorDetail', () => {
+  it('returns only the server text, or null', () => {
+    expect(httpErrorDetail(httpError(400, { human_readable: 'Bad', error: 'ignored' }))).toBe(
+      'Bad',
+    );
+    expect(httpErrorDetail(httpError(0, null))).toBeNull();
+    expect(httpErrorDetail(new Error('client'))).toBeNull();
+  });
+});
+
+describe('showHttpError', () => {
+  it('opens a snackbar with the extracted message', () => {
+    const snack = { open: vi.fn() };
+    showHttpError(snack, httpError(400, { human_readable: 'Bad' }), 'Failed to save');
+    expect(snack.open).toHaveBeenCalledWith('Failed to save: Bad', 'Close', { duration: 5000 });
+  });
+
+  it('stays silent on 401s, which the auth interceptor already handles', () => {
+    const snack = { open: vi.fn() };
+    const err = httpError(401, { human_readable: 'Unauthorized' });
+    expect(isAuthHandledError(err)).toBe(true);
+    showHttpError(snack, err, 'Failed to save');
+    expect(snack.open).not.toHaveBeenCalled();
+    expect(isAuthHandledError(httpError(403, null))).toBe(false);
+  });
+});

apps/rustnzb/frontend/src/app/core/http/http-error.ts

@@ -0,0 +1,80 @@
+import type { HttpErrorResponse } from '@angular/common/http';
+
+/** Anything with MatSnackBar's `open` signature (kept narrow for tests). */
+export interface SnackOpener {
+  open(message: string, action?: string, config?: { duration?: number }): unknown;
+}
+
+const MAX_TEXT_BODY = 300;
+
+function nonEmpty(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function fromBody(body: unknown): string | null {
+  if (typeof body === 'string') {
+    const text = body.trim();
+    if (!text) return null;
+    if (text.startsWith('{')) {
+      try {
+        return fromBody(JSON.parse(text));
+      } catch {
+        // Not JSON after all; treat it as plain text below.
+      }
+    }
+    // Short plain-text bodies (e.g. axum extractor rejections) are useful;
+    // HTML error pages from a proxy are not.
+    if (text.startsWith('<') || text.length > MAX_TEXT_BODY) return null;
+    return text;
+  }
+  if (body && typeof body === 'object') {
+    const b = body as Record<string, unknown>;
+    // Central API error shape first, then the legacy `{status:false, error}`
+    // shape, then older `{message}` bodies.
+    return nonEmpty(b['human_readable']) ?? nonEmpty(b['error']) ?? nonEmpty(b['message']);
+  }
+  return null;
+}
+
+/**
+ * The server's own explanation of a failed request, or `null` when the
+ * response carries nothing usable (network error, HTML proxy page, ...).
+ */
+export function httpErrorDetail(err: unknown): string | null {
+  // Duck-typed rather than `instanceof HttpErrorResponse` so errors that were
+  // re-thrown or built by hand with the same `{status, error}` shape work too.
+  if (!err || typeof err !== 'object' || !('error' in err)) return null;
+  return fromBody((err as HttpErrorResponse).error);
+}
+
+/**
+ * Turn a failed request into a user-facing message: the server's own
+ * explanation (`human_readable`, falling back to `error`/`message`) prefixed
+ * with what the user was trying to do, or just `fallback` when the response
+ * carries nothing usable.
+ */
+export function httpErrorMessage(err: unknown, fallback: string): string {
+  const detail = httpErrorDetail(err);
+  if (!detail || detail === fallback) return fallback;
+  return `${fallback}: ${detail}`;
+}
+
+/**
+ * A 401 reaching a component means the auth interceptor already tried to
+ * refresh the session and has redirected to the login page; a toast on top
+ * of that redirect is noise.
+ */
+export function isAuthHandledError(err: unknown): boolean {
+  return !!err && typeof err === 'object' && (err as HttpErrorResponse).status === 401;
+}
+
+/** Show a failed request as a toast, unless the auth flow is handling it. */
+export function showHttpError(
+  snack: SnackOpener,
+  err: unknown,
+  fallback: string,
+  duration = 5000,
+): void {
+  if (isAuthHandledError(err)) return;
+  snack.open(httpErrorMessage(err, fallback), 'Close', { duration });
+}

apps/rustnzb/frontend/src/app/core/models/queue.model.ts

@@ -6,6 +6,9 @@ export interface ServerArticleStats {
   bytes_downloaded: number;
 }
 
+/** Why a job or the whole queue is paused; `disk_space` lifts automatically. */
+export type PauseReason = 'manual' | 'global' | 'disk_space' | 'server';
+
 export interface NzbJob {
   id: string;
   name: string;
@@ -24,13 +27,15 @@ export interface NzbJob {
   speed_bps: number;
   error_message: string | null;
   server_stats: ServerArticleStats[];
+  pause_reason?: PauseReason | null;
 }
 
 export interface QueueResponse {
   jobs: NzbJob[];
   total: number;
   speed_bps: number;
   paused: boolean;
+  pause_reason?: PauseReason | null;
 }
 
 export interface StatusResponse {
@@ -43,6 +48,7 @@ export interface StatusResponse {
   disk_space_total: number;
   min_free_space_bytes: number;
   paused: boolean;
+  pause_reason?: PauseReason | null;
   pause_remaining_secs: number | null;
   webdav_available: boolean;
   webdav_enabled: boolean;

apps/rustnzb/frontend/src/app/features/auth/login.component.ts

@@ -3,6 +3,7 @@ import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
 import { Router } from '@angular/router';
 import { AuthService } from '../../core/services/auth.service';
+import { httpErrorDetail } from '../../core/http/http-error';
 
 @Component({
   selector: 'app-login',
@@ -210,10 +211,8 @@ export class LoginComponent implements OnInit {
           this.errorMessage.set('Invalid username or password.');
         } else if (err.status === 409) {
           this.errorMessage.set('An account already exists. Please sign in instead.');
-        } else if (err.error?.message) {
-          this.errorMessage.set(err.error.message);
         } else {
-          this.errorMessage.set('An error occurred. Please try again.');
+          this.errorMessage.set(httpErrorDetail(err) ?? 'An error occurred. Please try again.');
         }
       },
     });