refactor: remove legacy single-root APIs, defer filesystem I/O, enforce POSIX paths
- Remove legacy endpoints: /api/change-folder, /api/index, /api/scan, /api/status, /api/playback/resume-positions - Remove legacy global scanner module-level API from hivescan/scanner.py - Defer all filesystem validation to background task in server lifespan (macOS-safe) - CLI and winmain pass raw paths via MEDIAHIVE_ROOTS; no pre-startup validation - Enforce POSIX paths everywhere (as_posix(), no backslash leakage) - Remove MEDIAHIVE_PATH and MEDIAHIVE_DEFER_INITIAL_ROOT env vars - Update frontend api.ts to use per-root resume positions - Update docs/API.md and docs/multi-index-plan.md - Fix Python 2 style except clauses in hivescan/utils.py and scanning.py
This commit is contained in:
+15
-13
@@ -1,29 +1,31 @@
|
||||
# API
|
||||
|
||||
MediaHive exposes a small local API used by the desktop app and frontend.
|
||||
All media paths are scoped to a **root**, identified by a stable `root_id`.
|
||||
|
||||
## Endpoints
|
||||
|
||||
| Method | Path | Purpose |
|
||||
| --- | --- | --- |
|
||||
| `GET` | `/api/health` | Lightweight health check. |
|
||||
| `GET` | `/api/config` | Returns the currently selected media folder. |
|
||||
| `POST` | `/api/change-folder` | Persists and switches the active media folder without restarting the app. |
|
||||
| `GET` | `/api/index` | Returns the current in-memory media index. |
|
||||
| `GET` | `/api/playback/resume-positions` | Returns saved resume positions by media path. |
|
||||
| `GET` | `/api/status` | Returns scanner and library status information. |
|
||||
| `POST` | `/api/scan` | Triggers a new scan if the scanner is active. |
|
||||
| `POST` | `/api/play` | Opens a media file with the system player. |
|
||||
| `POST` | `/api/open-folder` | Opens a folder in the system file explorer, or selects a file in its parent folder. |
|
||||
| `GET` | `/api/config` | Returns the current root configuration. |
|
||||
| `GET` | `/api/roots` | List all active roots with status. |
|
||||
| `PUT` | `/api/roots` | Atomically replace the full root set. |
|
||||
| `GET` | `/api/roots/{root_id}/index` | Returns the media index for one root. |
|
||||
| `GET` | `/api/roots/{root_id}/status` | Returns scanner and library status for one root. |
|
||||
| `POST` | `/api/roots/{root_id}/scan` | Triggers a new scan for one root. |
|
||||
| `POST` | `/api/roots/{root_id}/play` | Opens a media file with the system player. |
|
||||
| `POST` | `/api/roots/{root_id}/open-folder` | Opens a folder in the system file explorer. |
|
||||
| `GET` | `/api/roots/{root_id}/playback/resume-positions` | Returns saved resume positions for one root. |
|
||||
| `GET` | `/api/player/status` | Returns whether remote player control is currently available. |
|
||||
| `GET` | `/api/mpcbe/status` | Reports whether MPC-BE's local web interface is reachable. |
|
||||
| `GET` | `/api/media/{file_path:path}` | Serves files from the active media root. |
|
||||
| `WS` | `/api/ws` | Streams live index updates and task progress events. |
|
||||
| `GET` | `/api/media/{root_id}/{file_path:path}` | Serves files from the specified root. |
|
||||
| `WS` | `/api/roots/{root_id}/ws` | Streams live index updates and task progress for one root. |
|
||||
|
||||
## Notes
|
||||
|
||||
- `POST /api/change-folder` validates the new folder, saves it to config, and switches the in-memory scanner asynchronously.
|
||||
- `POST /api/play` and `POST /api/open-folder` expect JSON request bodies matching the frontend calls.
|
||||
- `GET /api/media/{file_path:path}` is constrained to the current media root.
|
||||
- `PUT /api/roots` accepts `{ "roots": { "name": "/absolute/path", ... } }`, validates paths, and atomically swaps the active set.
|
||||
- `POST /api/roots/{root_id}/play` and `POST /api/roots/{root_id}/open-folder` expect JSON request bodies with `file_path` / `folder_path` relative to the root.
|
||||
- `GET /api/media/{root_id}/{file_path:path}` is constrained to the specified root; path traversal outside the root is rejected.
|
||||
- `GET /api/player/status` returns `{ "remote": true|false }`.
|
||||
- `GET /api/mpcbe/status` returns `false` on non-Windows platforms.
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
# Multi-Root Implementation Notes
|
||||
|
||||
## Overview
|
||||
|
||||
MediaHive now supports multiple independent media roots. Each root is a filesystem directory with its own index, scanner, and WebSocket stream. The frontend merges per-root state into a single reactive view.
|
||||
|
||||
## Architecture
|
||||
|
||||
### Root Identity
|
||||
|
||||
- **Root ID**: first 12 hex chars of SHA-256 of the *normalized* absolute path.
|
||||
- **Normalization**: resolve symlinks, lower-case Windows drive letter, strip trailing slashes, forward slashes only (`as_posix()`).
|
||||
- **Name**: derived from path basename; collisions resolved with `2`, `3`, … suffix.
|
||||
|
||||
### Per-Root Runtime (`RootContext`)
|
||||
|
||||
Each active root gets an isolated `RootContext` managed by the `Supervisor`:
|
||||
|
||||
- `root_id`, `root_path` — stable identifiers
|
||||
- `IndexStore` — owns snapshot at `<root>/.mediahive/index.json`
|
||||
- `RootScanner` — per-root scanning instance (replaced legacy global scanner)
|
||||
- `asyncio.Queue` + consumer task — bridges scanner events to WebSocket
|
||||
- `status`: `idle` | `loading` | `ready` | `scanning` | `error`
|
||||
|
||||
### Supervisor
|
||||
|
||||
- Holds `dict[str, RootContext]` keyed by `root_id`.
|
||||
- `replace_roots(new_roots)` atomically swaps the active set:
|
||||
1. Validate & canonicalize paths.
|
||||
2. Compute `root_id` for each.
|
||||
3. Prepare new `RootContext`s (load snapshots).
|
||||
4. Swap dict atomically.
|
||||
5. Stop removed contexts in background with bounded timeout.
|
||||
- Exposes merged read helpers (`merged_index`, `all_statuses`).
|
||||
|
||||
### Item IDs
|
||||
|
||||
Every `Movie.id` and `Series.id` is namespaced with its `root_id`:
|
||||
- Format: `{root_id}:{content_hash}`
|
||||
- Old snapshots are auto-migrated on load: IDs lacking the prefix get it prepended.
|
||||
|
||||
## API
|
||||
|
||||
| Endpoint | Description |
|
||||
|----------|-------------|
|
||||
| `GET /api/roots` | List all roots (name, path, root_id, status) |
|
||||
| `PUT /api/roots` | Atomically replace full root map `{name: path}` |
|
||||
| `GET /api/roots/{root_id}/index` | Full index for one root |
|
||||
| `GET /api/roots/{root_id}/status` | Per-root scanning/loading/error state |
|
||||
| `POST /api/roots/{root_id}/scan` | Trigger scan for one root |
|
||||
| `WS /api/roots/{root_id}/ws` | Per-root WebSocket (init/upsert/remove/task) |
|
||||
| `GET /api/media/{root_id}/{path:path}` | Serve media file scoped to root |
|
||||
| `POST /api/roots/{root_id}/play` | Play file within root |
|
||||
| `POST /api/roots/{root_id}/open-folder` | Open folder within root |
|
||||
| `GET /api/roots/{root_id}/playback/resume-positions` | Per-root resume positions |
|
||||
| `POST /api/ui/pick-folder` | Native OS folder picker (returns path) |
|
||||
|
||||
> **Removed legacy endpoints**: `/api/change-folder`, `/api/index`, `/api/scan`, `/api/status`, `/api/playback/resume-positions`. No backwards compatibility is maintained.
|
||||
|
||||
## macOS Startup Safety
|
||||
|
||||
The server **must not** touch the filesystem during startup, because macOS may show permission dialogs that block the event loop and prevent the HTTP server from accepting requests.
|
||||
|
||||
- `lifespan()` creates a background task (`_activate_all_roots()`) and immediately yields.
|
||||
- All filesystem validation (`exists()`, `is_dir()`, `resolve()`) runs in a thread pool via `asyncio.to_thread()`.
|
||||
- CLI entry points (`__main__.py`, `winmain.py`, `hivescan/__main__.py`) pass raw paths via the `MEDIAHIVE_ROOTS` environment variable; they do **not** validate paths before starting the server.
|
||||
|
||||
## POSIX Path Enforcement
|
||||
|
||||
All stored and transmitted paths use forward slashes exclusively:
|
||||
|
||||
- `_normalize_path()` always returns POSIX paths.
|
||||
- Config stores `p.as_posix()`.
|
||||
- URLs use `/` separators.
|
||||
- `Path(root_path) / relative_path` works correctly on Windows because `Path` accepts POSIX separators.
|
||||
|
||||
## Config Migration
|
||||
|
||||
- Old `media_folder` string is auto-migrated to `roots: {basename: path}` on load.
|
||||
- `roots` is persisted back to TOML config.
|
||||
|
||||
## Scanner
|
||||
|
||||
- Legacy global module-level scanner API was removed from `hivescan/scanner.py`.
|
||||
- `RootScanner` is the only scanning interface.
|
||||
- Each `RootScanner` owns its own `showreel_queue`, `scan_task`, `rescan_worker_task`, and `_seen_mtimes`.
|
||||
|
||||
## Frontend
|
||||
|
||||
- `useMediaWebSocket.ts` manages one WebSocket per active root.
|
||||
- `App.vue` merges per-root `movieMap`/`seriesMap` into a single `mediaIndex`.
|
||||
- `Header.vue` provides add/remove root UI via `PUT /api/roots`.
|
||||
- All media URLs are root-qualified (`/api/media/{root_id}/...`).
|
||||
+77
-4
@@ -184,7 +184,7 @@
|
||||
import { ref, computed, onMounted, onUnmounted, watch } from 'vue';
|
||||
import { useRouter, useRoute } from 'vue-router';
|
||||
import type { Movie, Series, MediaItem, EpisodeWithSeries, MatchedPerson, MatchedEpisode, TaskInfo } from './types';
|
||||
import { playMedia, openFolder, isMpcBeReachable, fetchResumePositions, normalizeMediaPath, getPlayerStatus } from './api';
|
||||
import { playMedia, openFolder, isMpcBeReachable, fetchResumePositions, normalizeMediaPath, getPlayerStatus, fetchRoots } from './api';
|
||||
import { useKeyboardNavigation } from './composables/useKeyboardNavigation';
|
||||
import { useMediaWebSocket } from './composables/useMediaWebSocket';
|
||||
import Header from './components/Header.vue';
|
||||
@@ -226,11 +226,53 @@ function normalizeHistoryPath(value: string): string {
|
||||
}
|
||||
|
||||
// WebSocket-driven media index
|
||||
const { mediaIndex, loading, error, connected: wsConnected, tasks } = useMediaWebSocket();
|
||||
const { mediaIndex, loading, error, connected: wsConnected, tasks, setActiveRoots } = useMediaWebSocket();
|
||||
|
||||
// Active tasks for the debug overlay
|
||||
const activeTasks = computed<TaskInfo[]>(() => Array.from(tasks.value.values()));
|
||||
|
||||
// Poll for active roots and connect WS to them
|
||||
const rootStatuses = ref<Map<string, { path: string; status: string }>>(new Map());
|
||||
|
||||
async function refreshRoots() {
|
||||
try {
|
||||
const roots = await fetchRoots();
|
||||
const newMap = new Map<string, { path: string; status: string }>();
|
||||
const activeIds: string[] = [];
|
||||
for (const r of roots) {
|
||||
newMap.set(r.root_id, { path: r.path, status: r.status });
|
||||
if (r.status === 'ready' || r.status === 'scanning' || r.status === 'loading') {
|
||||
activeIds.push(r.root_id);
|
||||
}
|
||||
}
|
||||
rootStatuses.value = newMap;
|
||||
setActiveRoots(activeIds);
|
||||
} catch (e) {
|
||||
console.error('Failed to fetch roots:', e);
|
||||
}
|
||||
}
|
||||
|
||||
let rootsPollTimer: number | null = null;
|
||||
function startRootsPolling() {
|
||||
if (rootsPollTimer !== null) return;
|
||||
void refreshRoots();
|
||||
rootsPollTimer = window.setInterval(refreshRoots, 5000);
|
||||
}
|
||||
function stopRootsPolling() {
|
||||
if (rootsPollTimer !== null) {
|
||||
window.clearInterval(rootsPollTimer);
|
||||
rootsPollTimer = null;
|
||||
}
|
||||
}
|
||||
|
||||
onMounted(() => {
|
||||
startRootsPolling();
|
||||
});
|
||||
|
||||
onUnmounted(() => {
|
||||
stopRootsPolling();
|
||||
});
|
||||
|
||||
const searchResults = ref<MediaItem[]>([]);
|
||||
const isSearching = ref(false);
|
||||
const mpcBeConnected = ref(false);
|
||||
@@ -609,6 +651,7 @@ function movieToMediaItem(movie: Movie): MediaItem {
|
||||
type: 'movies',
|
||||
resolution: resolution,
|
||||
data: movie,
|
||||
root_id: movie.root_id,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -637,6 +680,7 @@ function seriesToMediaItem(series: Series): MediaItem {
|
||||
showreel_source_sets: reelSourceSets.length > 0 ? reelSourceSets : null,
|
||||
type: 'series',
|
||||
data: series,
|
||||
root_id: series.root_id,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1430,10 +1474,34 @@ function reloadPage() {
|
||||
window.location.reload();
|
||||
}
|
||||
|
||||
function findRootIdForPath(filePath: string): string | null {
|
||||
if (!mediaIndex.value) return null;
|
||||
for (const movie of mediaIndex.value.movies) {
|
||||
for (const torrent of Object.values(movie.torrents || {})) {
|
||||
if (torrent.playable_file === filePath) return movie.root_id;
|
||||
}
|
||||
}
|
||||
for (const series of mediaIndex.value.series) {
|
||||
for (const season of series.seasons || []) {
|
||||
for (const episode of season.episodes || []) {
|
||||
for (const torrent of Object.values(episode.torrents || {})) {
|
||||
if (torrent.playable_file === filePath) return series.root_id;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
async function handlePlay(filePath: string) {
|
||||
const rootId = findRootIdForPath(filePath);
|
||||
if (!rootId) {
|
||||
console.error('Cannot play: unknown root for path', filePath);
|
||||
return;
|
||||
}
|
||||
mpcBeOpeningUntil.value = Date.now() + MPC_BE_OPENING_GRACE_MS;
|
||||
try {
|
||||
await playMedia(filePath);
|
||||
await playMedia(rootId, filePath);
|
||||
const connected = await tryConnectMpcBe();
|
||||
if (connected) {
|
||||
mpcBeConnected.value = true;
|
||||
@@ -1445,8 +1513,13 @@ async function handlePlay(filePath: string) {
|
||||
}
|
||||
|
||||
async function handleOpenFolder(folderPath: string) {
|
||||
const rootId = findRootIdForPath(folderPath);
|
||||
if (!rootId) {
|
||||
console.error('Cannot open folder: unknown root for path', folderPath);
|
||||
return;
|
||||
}
|
||||
try {
|
||||
await openFolder(folderPath);
|
||||
await openFolder(rootId, folderPath);
|
||||
} catch (e) {
|
||||
console.error('Failed to open folder:', e);
|
||||
}
|
||||
|
||||
+72
-42
@@ -1,9 +1,22 @@
|
||||
import type { MediaIndex } from './types';
|
||||
|
||||
|
||||
export interface PlayerStatus {
|
||||
remote: boolean;
|
||||
}
|
||||
|
||||
export interface RootStatus {
|
||||
root_id: string;
|
||||
path: string;
|
||||
status: string;
|
||||
error: string | null;
|
||||
movies: number;
|
||||
series: number;
|
||||
}
|
||||
|
||||
export interface RootsResponse {
|
||||
roots: RootStatus[];
|
||||
}
|
||||
|
||||
export function normalizeMediaPath(input: string): string {
|
||||
return input
|
||||
.replace(/\\/g, '/')
|
||||
@@ -71,12 +84,53 @@ export function getVideoSourceAttributes(path: string | null | undefined): Video
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the media index from the server
|
||||
* Fetch active roots and their statuses
|
||||
*/
|
||||
export async function loadMediaIndex(): Promise<MediaIndex> {
|
||||
const response = await fetch('/api/index');
|
||||
export async function fetchRoots(): Promise<RootStatus[]> {
|
||||
const response = await fetch('/api/roots');
|
||||
if (!response.ok) {
|
||||
throw new Error(`Failed to load media index: ${response.statusText}`);
|
||||
throw new Error(`Failed to load roots: ${response.statusText}`);
|
||||
}
|
||||
const data = await response.json();
|
||||
return data.roots || [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch merged resume positions from all roots.
|
||||
*/
|
||||
export async function fetchResumePositions(): Promise<Record<string, number>> {
|
||||
try {
|
||||
const roots = await fetchRoots();
|
||||
const merged: Record<string, number> = {};
|
||||
await Promise.all(
|
||||
roots.map(async (root) => {
|
||||
const response = await fetch(`/api/roots/${encodeURIComponent(root.root_id)}/playback/resume-positions`);
|
||||
if (!response.ok) return;
|
||||
const data = await response.json().catch(() => ({}));
|
||||
const positions = data?.resume_positions;
|
||||
if (positions && typeof positions === 'object') {
|
||||
Object.assign(merged, positions);
|
||||
}
|
||||
})
|
||||
);
|
||||
return merged;
|
||||
} catch {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Replace the full root set atomically
|
||||
*/
|
||||
export async function replaceRoots(roots: Record<string, string>): Promise<{ accepted: RootStatus[]; failed: unknown[] }> {
|
||||
const response = await fetch('/api/roots', {
|
||||
method: 'PUT',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ roots }),
|
||||
});
|
||||
if (!response.ok) {
|
||||
const err = await response.json().catch(() => ({ detail: response.statusText }));
|
||||
throw new Error(err.detail || response.statusText);
|
||||
}
|
||||
return response.json();
|
||||
}
|
||||
@@ -84,10 +138,10 @@ export async function loadMediaIndex(): Promise<MediaIndex> {
|
||||
/**
|
||||
* Play a media file with the system's default player
|
||||
*/
|
||||
export async function playMedia(filePath: string): Promise<void> {
|
||||
export async function playMedia(rootId: string, filePath: string): Promise<void> {
|
||||
const normalizedPath = normalizeMediaPath(filePath);
|
||||
try {
|
||||
const response = await fetch('/api/play', {
|
||||
const response = await fetch(`/api/roots/${encodeURIComponent(rootId)}/play`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ file_path: normalizedPath }),
|
||||
@@ -105,10 +159,10 @@ export async function playMedia(filePath: string): Promise<void> {
|
||||
/**
|
||||
* Open a folder in the system file manager
|
||||
*/
|
||||
export async function openFolder(folderPath: string): Promise<void> {
|
||||
export async function openFolder(rootId: string, folderPath: string): Promise<void> {
|
||||
const normalizedPath = normalizeMediaPath(folderPath);
|
||||
try {
|
||||
const response = await fetch('/api/open-folder', {
|
||||
const response = await fetch(`/api/roots/${encodeURIComponent(rootId)}/open-folder`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ folder_path: normalizedPath }),
|
||||
@@ -148,18 +202,6 @@ export async function isMpcBeReachable(): Promise<boolean> {
|
||||
}
|
||||
}
|
||||
|
||||
export async function fetchResumePositions(): Promise<Record<string, number>> {
|
||||
try {
|
||||
const response = await fetch('/api/playback/resume-positions');
|
||||
if (!response.ok) return {};
|
||||
const data = await response.json().catch(() => ({}));
|
||||
const resumePositions = data?.resume_positions;
|
||||
return resumePositions && typeof resumePositions === 'object' ? resumePositions : {};
|
||||
} catch {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a cover path to a displayable URL.
|
||||
* Uses FastAPI server for async file serving.
|
||||
@@ -167,7 +209,7 @@ export async function fetchResumePositions(): Promise<Record<string, number>> {
|
||||
* The path comes from the server already converted to Windows format (Z:\...)
|
||||
* Paths starting with '/' are TMDB relative paths that weren't fetched - ignore them
|
||||
*/
|
||||
export function getCoverUrl(coverPath: string | null): string {
|
||||
export function getCoverUrl(coverPath: string | null, rootId?: string | null): string {
|
||||
if (!coverPath) {
|
||||
return '';
|
||||
}
|
||||
@@ -177,7 +219,7 @@ export function getCoverUrl(coverPath: string | null): string {
|
||||
}
|
||||
|
||||
// Convert relative path to URL path for FastAPI server
|
||||
// .mediahive/covers/Movies/... -> /media/.mediahive/covers/Movies/...
|
||||
// .mediahive/covers/Movies/... -> /api/media/{root_id}/.mediahive/covers/Movies/...
|
||||
let urlPath = coverPath;
|
||||
|
||||
// Remove drive letter (Z:) and convert backslashes to forward slashes
|
||||
@@ -194,30 +236,18 @@ export function getCoverUrl(coverPath: string | null): string {
|
||||
// Encode URI components but preserve slashes
|
||||
const encodedPath = urlPath.split('/').map(segment => encodeURIComponent(segment)).join('/');
|
||||
|
||||
return `/api/media${encodedPath}`;
|
||||
const rid = rootId || 'unknown';
|
||||
return `/api/media/${encodeURIComponent(rid)}${encodedPath}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invoke the native OS folder picker via pywebview, then switch the server's
|
||||
* media folder in-place and reload the page. Only works inside the packaged
|
||||
* desktop app.
|
||||
* Invoke the native OS folder picker via pywebview, then add the selected
|
||||
* folder to the server's root list. Only works inside the packaged desktop app.
|
||||
*/
|
||||
export async function pickFolderAndRestart(): Promise<void> {
|
||||
export async function pickFolderAndAddRoot(): Promise<string | null> {
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
const api = (window as any).pywebview?.api;
|
||||
if (!api) return;
|
||||
if (!api) return null;
|
||||
const folder: string | null = await api.pick_folder();
|
||||
if (!folder) return;
|
||||
const res = await fetch('/api/change-folder', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ folder }),
|
||||
});
|
||||
if (res.ok) {
|
||||
// Give the server a moment to complete the background folder switch before reloading
|
||||
setTimeout(() => window.location.reload(), 500);
|
||||
} else {
|
||||
const err = await res.json().catch(() => ({ detail: res.statusText }));
|
||||
alert(`Failed to change folder: ${err.detail || res.statusText}`);
|
||||
}
|
||||
return folder;
|
||||
}
|
||||
|
||||
@@ -472,26 +472,26 @@ function getImageUrl(item: MediaItem): string | undefined {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return getCoverUrl(imagePath);
|
||||
return getCoverUrl(imagePath, item.root_id);
|
||||
}
|
||||
|
||||
function getVideoSources(item: MediaItem): Array<{ src: string; type: string; codecs: string }> {
|
||||
if (isVideoPath(item.cover_path)) {
|
||||
return [{ src: getVideoPreviewUrl(getCoverUrl(item.cover_path)), ...getVideoSourceAttributes(item.cover_path) }];
|
||||
return [{ src: getVideoPreviewUrl(getCoverUrl(item.cover_path, item.root_id)), ...getVideoSourceAttributes(item.cover_path) }];
|
||||
}
|
||||
|
||||
const showreelSourceSets = item.showreel_source_sets;
|
||||
if (showreelSourceSets && showreelSourceSets.length > 0) {
|
||||
return showreelSourceSets[0]
|
||||
.filter(path => isVideoPath(path))
|
||||
.map(path => ({ src: getVideoPreviewUrl(getCoverUrl(path)), ...getVideoSourceAttributes(path) }));
|
||||
.map(path => ({ src: getVideoPreviewUrl(getCoverUrl(path, item.root_id)), ...getVideoSourceAttributes(path) }));
|
||||
}
|
||||
|
||||
const showreel = item.showreel_images;
|
||||
if (showreel && showreel.length > 0) {
|
||||
return showreel
|
||||
.filter(path => isVideoPath(path))
|
||||
.map(path => ({ src: getVideoPreviewUrl(getCoverUrl(path)), ...getVideoSourceAttributes(path) }));
|
||||
.map(path => ({ src: getVideoPreviewUrl(getCoverUrl(path, item.root_id)), ...getVideoSourceAttributes(path) }));
|
||||
}
|
||||
|
||||
return [];
|
||||
|
||||
@@ -62,16 +62,57 @@
|
||||
<span>Player Open</span>
|
||||
</div>
|
||||
|
||||
<div v-if="isDesktopApp" class="header-settings">
|
||||
<div class="header-settings">
|
||||
<button
|
||||
class="header-settings-btn"
|
||||
title="Change media folder"
|
||||
@click="changeFolder"
|
||||
title="Manage media roots"
|
||||
@click="showRootsPanel = !showRootsPanel"
|
||||
>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
|
||||
<path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/>
|
||||
</svg>
|
||||
</button>
|
||||
|
||||
<!-- Roots management dropdown -->
|
||||
<div v-if="showRootsPanel" class="roots-panel">
|
||||
<div class="roots-panel-header">
|
||||
<span class="roots-panel-title">Media Roots</span>
|
||||
<button class="roots-panel-close" @click="showRootsPanel = false">×</button>
|
||||
</div>
|
||||
<div class="roots-list">
|
||||
<div
|
||||
v-for="root in roots"
|
||||
:key="root.root_id"
|
||||
class="roots-item"
|
||||
:class="`roots-item--${root.status}`"
|
||||
>
|
||||
<div class="roots-item-info">
|
||||
<span class="roots-item-name">{{ root.name }}</span>
|
||||
<span class="roots-item-path">{{ root.path }}</span>
|
||||
</div>
|
||||
<div class="roots-item-meta">
|
||||
<span class="roots-item-status">{{ root.status }}</span>
|
||||
<button
|
||||
v-if="roots.length > 1"
|
||||
class="roots-item-remove"
|
||||
@click="removeRoot(root.root_id)"
|
||||
title="Remove root"
|
||||
>
|
||||
×
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="roots-actions">
|
||||
<button
|
||||
v-if="isDesktopApp"
|
||||
class="roots-add-btn"
|
||||
@click="addRoot"
|
||||
>
|
||||
+ Add Folder…
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</header>
|
||||
</template>
|
||||
@@ -81,7 +122,14 @@ import { ref, watch, computed, onMounted, onUnmounted } from 'vue';
|
||||
import { useRouter } from 'vue-router';
|
||||
import { navAttrs } from '../composables/useKeyboardNavigation';
|
||||
import logoUrl from '../assets/mediahive.webp';
|
||||
import { pickFolderAndRestart } from '../api';
|
||||
import { fetchRoots, replaceRoots, pickFolderAndAddRoot } from '../api';
|
||||
|
||||
interface RootEntry {
|
||||
root_id: string;
|
||||
name: string;
|
||||
path: string;
|
||||
status: string;
|
||||
}
|
||||
|
||||
const props = defineProps<{
|
||||
currentView: 'movies' | 'series';
|
||||
@@ -100,18 +148,68 @@ const router = useRouter();
|
||||
const searchInputRef = ref<HTMLInputElement | null>(null);
|
||||
const localSearch = ref(props.searchQuery);
|
||||
|
||||
// True only when running inside the packaged pywebview desktop app.
|
||||
// pywebview injects window.pywebview asynchronously, so we listen for the
|
||||
// 'pywebviewready' event rather than checking at component creation time.
|
||||
const isDesktopApp = ref(typeof (window as any).pywebview !== 'undefined');
|
||||
function _onPywebviewReady() { isDesktopApp.value = true; }
|
||||
window.addEventListener('pywebviewready', _onPywebviewReady, { once: true });
|
||||
onUnmounted(() => window.removeEventListener('pywebviewready', _onPywebviewReady));
|
||||
|
||||
async function changeFolder() {
|
||||
await pickFolderAndRestart();
|
||||
const showRootsPanel = ref(false);
|
||||
const roots = ref<RootEntry[]>([]);
|
||||
|
||||
async function refreshRoots() {
|
||||
try {
|
||||
const data = await fetchRoots();
|
||||
roots.value = data.map(r => ({
|
||||
root_id: r.root_id,
|
||||
name: r.path.split('/').pop() || r.path.split('\\').pop() || r.root_id,
|
||||
path: r.path,
|
||||
status: r.status,
|
||||
}));
|
||||
} catch (e) {
|
||||
console.error('Failed to fetch roots:', e);
|
||||
}
|
||||
}
|
||||
|
||||
async function removeRoot(rootId: string) {
|
||||
const filtered = roots.value.filter(r => r.root_id !== rootId);
|
||||
const newRoots = Object.fromEntries(filtered.map(r => [r.name, r.path]));
|
||||
try {
|
||||
await replaceRoots(newRoots);
|
||||
await refreshRoots();
|
||||
} catch (e) {
|
||||
console.error('Failed to remove root:', e);
|
||||
alert('Failed to remove root');
|
||||
}
|
||||
}
|
||||
|
||||
async function addRoot() {
|
||||
const folder = await pickFolderAndAddRoot();
|
||||
if (!folder) return;
|
||||
const name = folder.split('/').pop() || folder.split('\\').pop() || 'media';
|
||||
// Resolve name collisions
|
||||
let uniqueName = name;
|
||||
let suffix = 2;
|
||||
const currentNames = new Set(roots.value.map(r => r.name));
|
||||
while (currentNames.has(uniqueName)) {
|
||||
uniqueName = `${name}${suffix}`;
|
||||
suffix++;
|
||||
}
|
||||
const newRoots = Object.fromEntries(roots.value.map(r => [r.name, r.path]));
|
||||
newRoots[uniqueName] = folder;
|
||||
try {
|
||||
await replaceRoots(newRoots);
|
||||
await refreshRoots();
|
||||
showRootsPanel.value = false;
|
||||
} catch (e) {
|
||||
console.error('Failed to add root:', e);
|
||||
alert('Failed to add root');
|
||||
}
|
||||
}
|
||||
|
||||
watch(showRootsPanel, (visible) => {
|
||||
if (visible) void refreshRoots();
|
||||
});
|
||||
|
||||
// Check if we're on a detail page
|
||||
const isDetailPage = computed(() => {
|
||||
return props.position === 'after-movie-header' || props.position === 'after-series-hero';
|
||||
@@ -213,4 +311,149 @@ onUnmounted(() => {
|
||||
background: #22c55e;
|
||||
box-shadow: 0 0 0 4px rgba(34, 197, 94, 0.18);
|
||||
}
|
||||
|
||||
.header-settings {
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.roots-panel {
|
||||
position: absolute;
|
||||
top: calc(100% + 8px);
|
||||
right: 0;
|
||||
width: 320px;
|
||||
background: rgba(20, 20, 20, 0.95);
|
||||
backdrop-filter: blur(16px);
|
||||
border: 1px solid rgba(255, 255, 255, 0.1);
|
||||
border-radius: 12px;
|
||||
padding: 16px;
|
||||
z-index: 1000;
|
||||
box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
|
||||
}
|
||||
|
||||
.roots-panel-header {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
margin-bottom: 12px;
|
||||
}
|
||||
|
||||
.roots-panel-title {
|
||||
font-weight: 600;
|
||||
font-size: 0.95rem;
|
||||
}
|
||||
|
||||
.roots-panel-close {
|
||||
background: none;
|
||||
border: none;
|
||||
color: var(--text-secondary);
|
||||
font-size: 1.2rem;
|
||||
cursor: pointer;
|
||||
padding: 0 4px;
|
||||
}
|
||||
|
||||
.roots-list {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 8px;
|
||||
max-height: 240px;
|
||||
overflow-y: auto;
|
||||
}
|
||||
|
||||
.roots-item {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
padding: 8px 10px;
|
||||
background: rgba(255, 255, 255, 0.05);
|
||||
border-radius: 8px;
|
||||
gap: 8px;
|
||||
}
|
||||
|
||||
.roots-item--ready {
|
||||
border-left: 3px solid #22c55e;
|
||||
}
|
||||
|
||||
.roots-item--scanning {
|
||||
border-left: 3px solid #f59e0b;
|
||||
}
|
||||
|
||||
.roots-item--loading {
|
||||
border-left: 3px solid #3b82f6;
|
||||
}
|
||||
|
||||
.roots-item--error {
|
||||
border-left: 3px solid #ef4444;
|
||||
}
|
||||
|
||||
.roots-item-info {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
.roots-item-name {
|
||||
font-size: 0.85rem;
|
||||
font-weight: 500;
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.roots-item-path {
|
||||
font-size: 0.75rem;
|
||||
color: var(--text-secondary);
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
|
||||
.roots-item-meta {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.roots-item-status {
|
||||
font-size: 0.7rem;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.5px;
|
||||
color: var(--text-muted);
|
||||
}
|
||||
|
||||
.roots-item-remove {
|
||||
background: none;
|
||||
border: none;
|
||||
color: var(--text-secondary);
|
||||
font-size: 1rem;
|
||||
cursor: pointer;
|
||||
padding: 0 4px;
|
||||
line-height: 1;
|
||||
}
|
||||
|
||||
.roots-item-remove:hover {
|
||||
color: #ef4444;
|
||||
}
|
||||
|
||||
.roots-actions {
|
||||
margin-top: 12px;
|
||||
padding-top: 12px;
|
||||
border-top: 1px solid rgba(255, 255, 255, 0.1);
|
||||
}
|
||||
|
||||
.roots-add-btn {
|
||||
width: 100%;
|
||||
padding: 8px;
|
||||
background: rgba(255, 255, 255, 0.08);
|
||||
border: 1px dashed rgba(255, 255, 255, 0.2);
|
||||
border-radius: 8px;
|
||||
color: var(--text-primary);
|
||||
font-size: 0.85rem;
|
||||
cursor: pointer;
|
||||
transition: background 0.2s;
|
||||
}
|
||||
|
||||
.roots-add-btn:hover {
|
||||
background: rgba(255, 255, 255, 0.15);
|
||||
}
|
||||
</style>
|
||||
|
||||
@@ -47,7 +47,7 @@ const emit = defineEmits<{
|
||||
}>();
|
||||
|
||||
const coverUrl = computed(() => {
|
||||
return getCoverUrl(props.item.cover_path);
|
||||
return getCoverUrl(props.item.cover_path, props.item.root_id);
|
||||
});
|
||||
|
||||
const resolution = computed(() => {
|
||||
|
||||
@@ -92,16 +92,16 @@ const posterImageUrl = computed(() => {
|
||||
if (!props.item.cover_path || isVideoPath(props.item.cover_path)) {
|
||||
return null;
|
||||
}
|
||||
return getCoverUrl(props.item.cover_path);
|
||||
return getCoverUrl(props.item.cover_path, props.item.root_id);
|
||||
});
|
||||
|
||||
const posterVideoUrl = computed(() => {
|
||||
if (props.item.cover_path && isVideoPath(props.item.cover_path)) {
|
||||
return getCoverUrl(props.item.cover_path);
|
||||
return getCoverUrl(props.item.cover_path, props.item.root_id);
|
||||
}
|
||||
|
||||
const fallbackVideo = props.item.showreel_images?.find(path => isVideoPath(path));
|
||||
return fallbackVideo ? getCoverUrl(fallbackVideo) : null;
|
||||
return fallbackVideo ? getCoverUrl(fallbackVideo, props.item.root_id) : null;
|
||||
});
|
||||
|
||||
const rating = computed(() => {
|
||||
|
||||
@@ -113,7 +113,7 @@
|
||||
>
|
||||
<img
|
||||
v-if="castMember.profile_path && !castMember.profile_path.startsWith('/')"
|
||||
:src="getCoverUrl(castMember.profile_path)"
|
||||
:src="getCoverUrl(castMember.profile_path, item.root_id)"
|
||||
:alt="castMember.name"
|
||||
class="cast-photo"
|
||||
>
|
||||
@@ -341,7 +341,7 @@ watch(collageSlots, async (slots) => {
|
||||
}, { immediate: true });
|
||||
|
||||
function getShowreelUrl(path: string): string {
|
||||
return getVideoPreviewUrl(getCoverUrl(path));
|
||||
return getVideoPreviewUrl(getCoverUrl(path, props.item.root_id));
|
||||
}
|
||||
|
||||
function getShowreelSourceAttributes(path: string): VideoSourceAttributes {
|
||||
@@ -359,7 +359,7 @@ const backdropStyle = computed(() => {
|
||||
if (props.item.type !== 'movies') return {};
|
||||
const movie = props.item.data as Movie;
|
||||
const imagePath = movie.backdrop_path;
|
||||
const imageUrl = getCoverUrl(imagePath);
|
||||
const imageUrl = getCoverUrl(imagePath, props.item.root_id);
|
||||
if (imageUrl) {
|
||||
return { backgroundImage: `url("${imageUrl}")` };
|
||||
}
|
||||
@@ -368,7 +368,7 @@ const backdropStyle = computed(() => {
|
||||
|
||||
const synopsisPosterUrl = computed(() => {
|
||||
if (props.item.type !== 'movies') return null;
|
||||
return getCoverUrl(props.item.cover_path);
|
||||
return getCoverUrl(props.item.cover_path, props.item.root_id);
|
||||
});
|
||||
|
||||
const movieGenres = computed(() => {
|
||||
|
||||
@@ -502,7 +502,7 @@ function handleEpisodeHover(key: string, isEntering: boolean) {
|
||||
// Backdrop URL - only use backdrop_path, fall back to collage (handled in template)
|
||||
const backdropUrl = computed(() => {
|
||||
if (props.series.info?.backdrop_path) {
|
||||
return getCoverUrl(props.series.info.backdrop_path);
|
||||
return getCoverUrl(props.series.info.backdrop_path, props.series.root_id);
|
||||
}
|
||||
return null;
|
||||
});
|
||||
@@ -523,7 +523,7 @@ const ratingClass = computed(() => {
|
||||
// Get season poster
|
||||
function getSeasonPoster(season: Season): string | undefined {
|
||||
if (season.poster_path) {
|
||||
return getCoverUrl(season.poster_path);
|
||||
return getCoverUrl(season.poster_path, props.series.root_id);
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
@@ -536,14 +536,14 @@ function getEpisodeVideoSources(episode: Episode): Array<{ src: string; type: st
|
||||
: [];
|
||||
|
||||
return sources.map((path) => ({
|
||||
src: getVideoPreviewUrl(getCoverUrl(path)),
|
||||
src: getVideoPreviewUrl(getCoverUrl(path, props.series.root_id)),
|
||||
...getVideoSourceAttributes(path),
|
||||
}));
|
||||
}
|
||||
|
||||
// Collage slice style for season posters
|
||||
function getCollageSliceStyle(season: Season, index: number) {
|
||||
const posterUrl = season.poster_path ? getCoverUrl(season.poster_path) : null;
|
||||
const posterUrl = season.poster_path ? getCoverUrl(season.poster_path, props.series.root_id) : null;
|
||||
const totalSlices = Math.min(seasonsWithPosters.value.length, 5);
|
||||
const sliceWidth = 100 / totalSlices;
|
||||
|
||||
|
||||
@@ -1,17 +1,24 @@
|
||||
import { ref, readonly, onUnmounted } from 'vue';
|
||||
import type { Movie, Series, MediaIndex, TaskInfo, WsMessage } from '../types';
|
||||
|
||||
interface RootState {
|
||||
rootId: string;
|
||||
ws: WebSocket | null;
|
||||
movieMap: Map<string, Movie>;
|
||||
seriesMap: Map<string, Series>;
|
||||
connected: boolean;
|
||||
reconnectTimer: ReturnType<typeof setTimeout> | null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Composable that connects to the MediaHive WebSocket and keeps
|
||||
* the media index updated in real time.
|
||||
* Composable that connects to per-root MediaHive WebSockets and keeps
|
||||
* a merged media index updated in real time.
|
||||
*
|
||||
* The server sends:
|
||||
* The server sends per-root:
|
||||
* - "init" → full index (movies + series) on connect
|
||||
* - "upsert" → single item inserted or updated
|
||||
* - "remove" → single item removed
|
||||
* - "task" → background task progress
|
||||
*
|
||||
* Messages are msgspec-encoded binary JSON with a "type" tag field.
|
||||
*/
|
||||
export function useMediaWebSocket() {
|
||||
const mediaIndex = ref<MediaIndex | null>(null);
|
||||
@@ -20,17 +27,16 @@ export function useMediaWebSocket() {
|
||||
const connected = ref(false);
|
||||
const tasks = ref<Map<string, TaskInfo>>(new Map());
|
||||
|
||||
let ws: WebSocket | null = null;
|
||||
let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
|
||||
const roots = ref<Map<string, RootState>>(new Map());
|
||||
let disposed = false;
|
||||
|
||||
// Lookup maps for fast upsert / remove
|
||||
const movieMap = new Map<string, Movie>();
|
||||
const seriesMap = new Map<string, Series>();
|
||||
|
||||
function buildIndex(): MediaIndex {
|
||||
const movies = Array.from(movieMap.values());
|
||||
const series = Array.from(seriesMap.values());
|
||||
const movies: Movie[] = [];
|
||||
const series: Series[] = [];
|
||||
for (const state of roots.value.values()) {
|
||||
movies.push(...state.movieMap.values());
|
||||
series.push(...state.seriesMap.values());
|
||||
}
|
||||
return {
|
||||
version: 0,
|
||||
generated_at: new Date().toISOString(),
|
||||
@@ -43,63 +49,57 @@ export function useMediaWebSocket() {
|
||||
};
|
||||
}
|
||||
|
||||
function handleMessage(event: MessageEvent) {
|
||||
try {
|
||||
// Server sends binary frames (msgspec json bytes)
|
||||
let text: string;
|
||||
if (event.data instanceof Blob) {
|
||||
// Will be handled by the blob reader below
|
||||
event.data.text().then((t) => processJson(t));
|
||||
return;
|
||||
} else if (event.data instanceof ArrayBuffer) {
|
||||
text = new TextDecoder().decode(event.data);
|
||||
} else {
|
||||
text = event.data as string;
|
||||
function updateMergedState() {
|
||||
mediaIndex.value = buildIndex();
|
||||
// Loading is done when at least one root has connected and sent init
|
||||
let anyConnected = false;
|
||||
for (const state of roots.value.values()) {
|
||||
if (state.connected) {
|
||||
anyConnected = true;
|
||||
break;
|
||||
}
|
||||
processJson(text);
|
||||
} catch (e) {
|
||||
console.error('[WS] Failed to handle message:', e);
|
||||
}
|
||||
if (anyConnected) {
|
||||
loading.value = false;
|
||||
error.value = null;
|
||||
}
|
||||
connected.value = anyConnected;
|
||||
}
|
||||
|
||||
function processJson(text: string) {
|
||||
function processJson(state: RootState, text: string) {
|
||||
const msg = JSON.parse(text) as WsMessage;
|
||||
|
||||
switch (msg.type) {
|
||||
case 'init': {
|
||||
movieMap.clear();
|
||||
seriesMap.clear();
|
||||
for (const m of msg.data.movies) movieMap.set(m.id, m);
|
||||
for (const s of msg.data.series) seriesMap.set(s.id, s);
|
||||
mediaIndex.value = buildIndex();
|
||||
loading.value = false;
|
||||
error.value = null;
|
||||
console.log(`[WS] init: ${movieMap.size} movies, ${seriesMap.size} series`);
|
||||
state.movieMap.clear();
|
||||
state.seriesMap.clear();
|
||||
for (const m of msg.data.movies) state.movieMap.set(m.id, m);
|
||||
for (const s of msg.data.series) state.seriesMap.set(s.id, s);
|
||||
updateMergedState();
|
||||
console.log(`[WS ${state.rootId}] init: ${state.movieMap.size} movies, ${state.seriesMap.size} series`);
|
||||
break;
|
||||
}
|
||||
case 'upsert': {
|
||||
if (msg.kind === 'movie') {
|
||||
movieMap.set(msg.item.id, msg.item as Movie);
|
||||
state.movieMap.set(msg.item.id, msg.item as Movie);
|
||||
} else {
|
||||
seriesMap.set(msg.item.id, msg.item as Series);
|
||||
state.seriesMap.set(msg.item.id, msg.item as Series);
|
||||
}
|
||||
// Rebuild the index ref so Vue detects the change
|
||||
mediaIndex.value = buildIndex();
|
||||
updateMergedState();
|
||||
break;
|
||||
}
|
||||
case 'remove': {
|
||||
if (msg.kind === 'movie') {
|
||||
movieMap.delete(msg.id);
|
||||
state.movieMap.delete(msg.id);
|
||||
} else {
|
||||
seriesMap.delete(msg.id);
|
||||
state.seriesMap.delete(msg.id);
|
||||
}
|
||||
mediaIndex.value = buildIndex();
|
||||
updateMergedState();
|
||||
break;
|
||||
}
|
||||
case 'task': {
|
||||
const info = msg.data;
|
||||
if (info.status === 'completed' || info.status === 'cancelled' || info.status === 'error') {
|
||||
// Keep finished tasks briefly so the UI can show completion
|
||||
tasks.value.set(info.id, info);
|
||||
setTimeout(() => {
|
||||
tasks.value.delete(info.id);
|
||||
@@ -108,71 +108,143 @@ export function useMediaWebSocket() {
|
||||
} else {
|
||||
tasks.value.set(info.id, info);
|
||||
}
|
||||
// Trigger reactivity
|
||||
tasks.value = new Map(tasks.value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function connect() {
|
||||
if (disposed) return;
|
||||
|
||||
// Build WS URL relative to current page
|
||||
const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
|
||||
const url = `${proto}//${location.host}/api/ws`;
|
||||
|
||||
console.log(`[WS] Connecting to ${url}...`);
|
||||
ws = new WebSocket(url);
|
||||
|
||||
ws.onopen = () => {
|
||||
connected.value = true;
|
||||
error.value = null;
|
||||
console.log('[WS] Connected');
|
||||
};
|
||||
|
||||
ws.onmessage = handleMessage;
|
||||
|
||||
ws.onclose = (ev) => {
|
||||
connected.value = false;
|
||||
console.log(`[WS] Closed (code=${ev.code})`);
|
||||
scheduleReconnect();
|
||||
};
|
||||
|
||||
ws.onerror = (ev) => {
|
||||
console.error('[WS] Error:', ev);
|
||||
if (!mediaIndex.value) {
|
||||
error.value = 'WebSocket connection failed';
|
||||
function handleMessage(state: RootState, event: MessageEvent) {
|
||||
try {
|
||||
let text: string;
|
||||
if (event.data instanceof Blob) {
|
||||
event.data.text().then((t) => processJson(state, t));
|
||||
return;
|
||||
} else if (event.data instanceof ArrayBuffer) {
|
||||
text = new TextDecoder().decode(event.data);
|
||||
} else {
|
||||
text = event.data as string;
|
||||
}
|
||||
};
|
||||
processJson(state, text);
|
||||
} catch (e) {
|
||||
console.error(`[WS ${state.rootId}] Failed to handle message:`, e);
|
||||
}
|
||||
}
|
||||
|
||||
function scheduleReconnect() {
|
||||
function connectRoot(rootId: string) {
|
||||
if (disposed) return;
|
||||
if (reconnectTimer) clearTimeout(reconnectTimer);
|
||||
reconnectTimer = setTimeout(() => {
|
||||
console.log('[WS] Reconnecting...');
|
||||
connect();
|
||||
}, 2000);
|
||||
const existing = roots.value.get(rootId);
|
||||
if (existing?.ws) {
|
||||
// Already connecting or connected
|
||||
return;
|
||||
}
|
||||
|
||||
const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
|
||||
const url = `${proto}//${location.host}/api/roots/${encodeURIComponent(rootId)}/ws`;
|
||||
|
||||
const state: RootState = {
|
||||
rootId,
|
||||
ws: null,
|
||||
movieMap: new Map(),
|
||||
seriesMap: new Map(),
|
||||
connected: false,
|
||||
reconnectTimer: null,
|
||||
};
|
||||
roots.value.set(rootId, state);
|
||||
|
||||
function doConnect() {
|
||||
if (disposed) return;
|
||||
console.log(`[WS ${rootId}] Connecting to ${url}...`);
|
||||
const ws = new WebSocket(url);
|
||||
state.ws = ws;
|
||||
|
||||
ws.onopen = () => {
|
||||
state.connected = true;
|
||||
updateMergedState();
|
||||
console.log(`[WS ${rootId}] Connected`);
|
||||
};
|
||||
|
||||
ws.onmessage = (ev) => handleMessage(state, ev);
|
||||
|
||||
ws.onclose = (ev) => {
|
||||
state.connected = false;
|
||||
state.ws = null;
|
||||
updateMergedState();
|
||||
console.log(`[WS ${rootId}] Closed (code=${ev.code})`);
|
||||
scheduleReconnect();
|
||||
};
|
||||
|
||||
ws.onerror = (ev) => {
|
||||
console.error(`[WS ${rootId}] Error:`, ev);
|
||||
if (!mediaIndex.value) {
|
||||
error.value = 'WebSocket connection failed';
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function scheduleReconnect() {
|
||||
if (disposed) return;
|
||||
if (state.reconnectTimer) clearTimeout(state.reconnectTimer);
|
||||
state.reconnectTimer = setTimeout(() => {
|
||||
console.log(`[WS ${rootId}] Reconnecting...`);
|
||||
doConnect();
|
||||
}, 2000);
|
||||
}
|
||||
|
||||
doConnect();
|
||||
}
|
||||
|
||||
function disconnectRoot(rootId: string) {
|
||||
const state = roots.value.get(rootId);
|
||||
if (!state) return;
|
||||
if (state.reconnectTimer) {
|
||||
clearTimeout(state.reconnectTimer);
|
||||
state.reconnectTimer = null;
|
||||
}
|
||||
if (state.ws) {
|
||||
state.ws.onclose = null;
|
||||
state.ws.close();
|
||||
state.ws = null;
|
||||
}
|
||||
state.connected = false;
|
||||
roots.value.delete(rootId);
|
||||
updateMergedState();
|
||||
}
|
||||
|
||||
function setActiveRoots(rootIds: string[]) {
|
||||
if (disposed) return;
|
||||
const desired = new Set(rootIds);
|
||||
const current = new Set(roots.value.keys());
|
||||
|
||||
// Add new roots
|
||||
for (const rid of desired) {
|
||||
if (!current.has(rid)) {
|
||||
connectRoot(rid);
|
||||
}
|
||||
}
|
||||
|
||||
// Remove old roots
|
||||
for (const rid of current) {
|
||||
if (!desired.has(rid)) {
|
||||
disconnectRoot(rid);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function disconnect() {
|
||||
disposed = true;
|
||||
if (reconnectTimer) {
|
||||
clearTimeout(reconnectTimer);
|
||||
reconnectTimer = null;
|
||||
}
|
||||
if (ws) {
|
||||
ws.onclose = null; // prevent reconnect
|
||||
ws.close();
|
||||
ws = null;
|
||||
for (const state of roots.value.values()) {
|
||||
if (state.reconnectTimer) {
|
||||
clearTimeout(state.reconnectTimer);
|
||||
}
|
||||
if (state.ws) {
|
||||
state.ws.onclose = null;
|
||||
state.ws.close();
|
||||
}
|
||||
}
|
||||
roots.value.clear();
|
||||
}
|
||||
|
||||
// Start the connection
|
||||
connect();
|
||||
|
||||
// Clean up on component unmount
|
||||
onUnmounted(disconnect);
|
||||
|
||||
return {
|
||||
@@ -181,6 +253,7 @@ export function useMediaWebSocket() {
|
||||
error: readonly(error),
|
||||
connected: readonly(connected),
|
||||
tasks: readonly(tasks),
|
||||
setActiveRoots,
|
||||
disconnect,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -69,6 +69,7 @@ export interface Movie {
|
||||
showreel_images: string[] | null;
|
||||
showreel_source_sets: string[][] | null;
|
||||
torrents: { [key: string]: Torrent };
|
||||
root_id: string | null;
|
||||
}
|
||||
|
||||
export interface Episode {
|
||||
@@ -104,6 +105,7 @@ export interface Series {
|
||||
cover_path: string | null;
|
||||
backdrop_path: string | null;
|
||||
seasons: Season[];
|
||||
root_id: string | null;
|
||||
}
|
||||
|
||||
export interface MediaStats {
|
||||
@@ -156,6 +158,7 @@ export interface MediaItem {
|
||||
type: MediaType;
|
||||
resolution?: string | null;
|
||||
data: Movie | Series | EpisodeWithSeries;
|
||||
root_id: string | null;
|
||||
// Optional search match info - only present in search results
|
||||
searchMatchInfo?: SearchMatchInfo;
|
||||
}
|
||||
|
||||
+24
-19
@@ -1,4 +1,5 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
@@ -9,20 +10,10 @@ DEFAULT_PORT = 8420
|
||||
DEVMODE = os.getenv("MEDIAHIVE_DEV") == "1"
|
||||
|
||||
|
||||
def resolve_media_root(path: str | None = None) -> Path:
|
||||
"""Resolve the media root folder from a path, MEDIAHIVE_PATH env, or cwd."""
|
||||
match Path(path or os.environ.get("MEDIAHIVE_PATH") or Path.cwd()).parts:
|
||||
case (*rest, ".mediahive", "index.json"):
|
||||
...
|
||||
case (*rest, ".mediahive"):
|
||||
...
|
||||
case rest:
|
||||
...
|
||||
mediaroot = Path(*rest).resolve()
|
||||
if not mediaroot.exists() or not mediaroot.is_dir():
|
||||
sys.stderr.write(f"Error: Folder does not exist: {mediaroot}\n")
|
||||
sys.exit(1)
|
||||
return mediaroot
|
||||
def _derive_name(path: str) -> str:
|
||||
"""Derive a root name from a path."""
|
||||
p = Path(path)
|
||||
return p.name or p.anchor.strip("/\\").lower() or "media"
|
||||
|
||||
|
||||
def main():
|
||||
@@ -30,9 +21,10 @@ def main():
|
||||
description="MediaHive - Media scanning, indexing, and streaming"
|
||||
)
|
||||
parser.add_argument(
|
||||
"media_folder",
|
||||
nargs="?",
|
||||
help="Path to the media folder (default: MEDIAHIVE_PATH or current directory)",
|
||||
"media_folders",
|
||||
nargs="*",
|
||||
metavar="MEDIA_FOLDER",
|
||||
help="One or more media folders to index (default: none — configure via UI or API)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-l",
|
||||
@@ -43,8 +35,21 @@ def main():
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
mediaroot = resolve_media_root(args.media_folder)
|
||||
os.environ["MEDIAHIVE_PATH"] = mediaroot.as_posix()
|
||||
if args.media_folders:
|
||||
roots: dict[str, str] = {}
|
||||
for path in args.media_folders:
|
||||
# Defer filesystem validation to the server so startup is never
|
||||
# blocked by macOS permission dialogs or missing paths.
|
||||
p = Path(path).expanduser()
|
||||
name = _derive_name(p.as_posix())
|
||||
# Resolve collisions
|
||||
base_name = name
|
||||
suffix = 2
|
||||
while name in roots:
|
||||
name = f"{base_name}{suffix}"
|
||||
suffix += 1
|
||||
roots[name] = p.as_posix()
|
||||
os.environ["MEDIAHIVE_ROOTS"] = json.dumps(roots)
|
||||
|
||||
dev = {"reload": True, "reload_dirs": ["mediahive"]}
|
||||
server.run(
|
||||
|
||||
+16
-1
@@ -16,6 +16,7 @@ import msgspec.toml
|
||||
|
||||
class Config(msgspec.Struct):
|
||||
media_folder: str | None = None
|
||||
roots: dict[str, str] | None = None
|
||||
|
||||
|
||||
def config_dir() -> Path:
|
||||
@@ -32,11 +33,25 @@ def config_path() -> Path:
|
||||
return config_dir() / "config.toml"
|
||||
|
||||
|
||||
def _migrate_legacy_media_folder(cfg: Config) -> Config:
|
||||
"""If roots is empty but media_folder exists, seed roots with it."""
|
||||
if cfg.roots:
|
||||
return cfg
|
||||
if not cfg.media_folder:
|
||||
return cfg
|
||||
path = Path(cfg.media_folder)
|
||||
name = path.name or path.anchor.strip("/\\").lower() or "media"
|
||||
# Resolve collisions simply by using the basename; if user had weird layout
|
||||
# they can rename via the UI later.
|
||||
return msgspec.structs.replace(cfg, roots={name: cfg.media_folder})
|
||||
|
||||
|
||||
def load_config() -> Config:
|
||||
path = config_path()
|
||||
if path.exists():
|
||||
try:
|
||||
return msgspec.toml.decode(path.read_bytes(), type=Config)
|
||||
cfg = msgspec.toml.decode(path.read_bytes(), type=Config)
|
||||
return _migrate_legacy_media_folder(cfg)
|
||||
except Exception:
|
||||
return Config()
|
||||
return Config()
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
from pathlib import Path
|
||||
@@ -16,11 +17,11 @@ Examples:
|
||||
|
||||
Exclude paths by creating .mediahive/scanignore (gitignore syntax).
|
||||
|
||||
The server exposes:
|
||||
WS /ws Live index updates & task progress
|
||||
POST /api/scan Trigger a new scan
|
||||
GET /api/status Current server status
|
||||
GET /api/index Full index as JSON (HTTP fallback)
|
||||
The server exposes per-root endpoints:
|
||||
WS /api/roots/{root_id}/ws Live index updates & task progress
|
||||
POST /api/roots/{root_id}/scan Trigger a new scan
|
||||
GET /api/roots/{root_id}/status Current root status
|
||||
GET /api/roots/{root_id}/index Full index as JSON (HTTP fallback)
|
||||
""",
|
||||
)
|
||||
parser.add_argument(
|
||||
@@ -41,12 +42,11 @@ The server exposes:
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
media_root = Path(args.media_folder).resolve()
|
||||
if not media_root.exists() or not media_root.is_dir():
|
||||
print(f"Error: Folder does not exist: {media_root}")
|
||||
exit(1)
|
||||
|
||||
os.environ["MEDIAHIVE_PATH"] = media_root.as_posix()
|
||||
# Defer filesystem validation to the server; pass raw path via env.
|
||||
media_root = Path(args.media_folder).expanduser()
|
||||
os.environ["MEDIAHIVE_ROOTS"] = json.dumps({
|
||||
media_root.name or "media": media_root.as_posix()
|
||||
})
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
|
||||
@@ -380,6 +380,7 @@ async def _process_movies(
|
||||
fetch_covers: bool,
|
||||
generate_showreels: bool,
|
||||
media_root: Optional[str] = None,
|
||||
root_id: Optional[str] = None,
|
||||
) -> AsyncIterator[Tuple[Movie, Optional[Tuple[str, Path, str]]]]:
|
||||
"""
|
||||
Async generator that processes all movies.
|
||||
@@ -473,7 +474,8 @@ async def _process_movies(
|
||||
year = group_data["year"]
|
||||
|
||||
display_title = tmdb_info.title
|
||||
item_id = hashlib.md5(f"movie:{tmdb_id}".encode()).hexdigest()[:12]
|
||||
content_hash = hashlib.md5(f"movie:{tmdb_id}".encode()).hexdigest()[:12]
|
||||
item_id = f"{root_id}:{content_hash}" if root_id else content_hash
|
||||
media_folder = get_media_folder_path(display_title, year, "movie", cover_dir)
|
||||
|
||||
# Find/download cover
|
||||
@@ -551,6 +553,7 @@ async def _process_movies(
|
||||
showreel_images=showreel_paths if showreel_paths else None,
|
||||
showreel_source_sets=showreel_source_sets if showreel_source_sets else None,
|
||||
torrents=torrents,
|
||||
root_id=root_id,
|
||||
)
|
||||
yield movie, showreel_task
|
||||
|
||||
@@ -559,7 +562,8 @@ async def _process_movies(
|
||||
items = group_data["items"]
|
||||
title = group_data["title"]
|
||||
year = group_data["year"]
|
||||
item_id = hashlib.md5(f"movie:{title}:{year}".encode()).hexdigest()[:12]
|
||||
content_hash = hashlib.md5(f"movie:{title}:{year}".encode()).hexdigest()[:12]
|
||||
item_id = f"{root_id}:{content_hash}" if root_id else content_hash
|
||||
|
||||
cover_path = (
|
||||
await find_cover_image(title, year, "movie", cover_dir)
|
||||
@@ -620,6 +624,7 @@ async def _process_movies(
|
||||
showreel_images=showreel_paths if showreel_paths else None,
|
||||
showreel_source_sets=showreel_source_sets if showreel_source_sets else None,
|
||||
torrents=torrents,
|
||||
root_id=root_id,
|
||||
)
|
||||
yield movie, showreel_task
|
||||
|
||||
@@ -630,6 +635,7 @@ async def _process_series(
|
||||
fetch_covers: bool,
|
||||
generate_showreels: bool,
|
||||
media_root: Optional[str] = None,
|
||||
root_id: Optional[str] = None,
|
||||
) -> AsyncIterator[Tuple[Series, List[Tuple[str, Path, int, int, str]]]]:
|
||||
"""
|
||||
Async generator that processes all series.
|
||||
@@ -714,7 +720,8 @@ async def _process_series(
|
||||
torrent_titles = group_data["torrent_titles"]
|
||||
|
||||
display_title = tmdb_info.title
|
||||
series_id = hashlib.md5(f"series:{tmdb_id}".encode()).hexdigest()[:12]
|
||||
content_hash = hashlib.md5(f"series:{tmdb_id}".encode()).hexdigest()[:12]
|
||||
series_id = f"{root_id}:{content_hash}" if root_id else content_hash
|
||||
|
||||
logger.debug(" [%d/%d] %s", series_idx, len(tmdb_groups), display_title)
|
||||
|
||||
@@ -779,6 +786,7 @@ async def _process_series(
|
||||
cover_path=make_relative_path(cover_path, media_root),
|
||||
backdrop_path=make_relative_path(backdrop_path, media_root),
|
||||
seasons=seasons_data,
|
||||
root_id=root_id,
|
||||
)
|
||||
yield series, ep_reel_tasks
|
||||
|
||||
@@ -786,7 +794,8 @@ async def _process_series(
|
||||
for key, group_data in no_tmdb_groups.items():
|
||||
items = group_data["items"]
|
||||
title = group_data["title"]
|
||||
series_id = hashlib.md5(f"series:{title}".encode()).hexdigest()[:12]
|
||||
content_hash = hashlib.md5(f"series:{title}".encode()).hexdigest()[:12]
|
||||
series_id = f"{root_id}:{content_hash}" if root_id else content_hash
|
||||
|
||||
cover_path = (
|
||||
await find_cover_image(title, None, "series", cover_dir)
|
||||
@@ -823,5 +832,6 @@ async def _process_series(
|
||||
newest=newest,
|
||||
cover_path=make_relative_path(cover_path, media_root),
|
||||
seasons=seasons_data,
|
||||
root_id=root_id,
|
||||
)
|
||||
yield series, ep_reel_tasks
|
||||
|
||||
+559
-581
File diff suppressed because it is too large
Load Diff
@@ -120,7 +120,7 @@ async def find_episode_files(
|
||||
episodes[ep_info].append(
|
||||
(Path(f).as_posix(), (await af.stat()).st_size)
|
||||
)
|
||||
except OSError, PermissionError:
|
||||
except (OSError, PermissionError):
|
||||
pass
|
||||
|
||||
_episode_files_cache[cache_key] = episodes
|
||||
@@ -197,7 +197,7 @@ async def find_playable_file(path: Path) -> Optional[str]:
|
||||
result = nested_video_ts_ifo.as_posix()
|
||||
_playable_file_cache[cache_key] = result
|
||||
return result
|
||||
except OSError, PermissionError:
|
||||
except (OSError, PermissionError):
|
||||
pass
|
||||
|
||||
# Find largest video file
|
||||
@@ -209,7 +209,7 @@ async def find_playable_file(path: Path) -> Optional[str]:
|
||||
if "sample" in Path(f).name.lower():
|
||||
continue
|
||||
video_files.append((Path(f).as_posix(), (await af.stat()).st_size))
|
||||
except OSError, PermissionError:
|
||||
except (OSError, PermissionError):
|
||||
pass
|
||||
|
||||
if not video_files:
|
||||
@@ -262,7 +262,7 @@ async def find_metadata_probe_file(playable_path: Optional[str]) -> Optional[str
|
||||
ts_num = name[4:6]
|
||||
size = (await af.stat()).st_size
|
||||
title_sets[ts_num].append((Path(f).as_posix(), size))
|
||||
except OSError, PermissionError:
|
||||
except (OSError, PermissionError):
|
||||
_bluray_probe_file_cache[cache_key] = None
|
||||
return None
|
||||
|
||||
@@ -304,7 +304,7 @@ async def find_metadata_probe_file(playable_path: Optional[str]) -> Optional[str
|
||||
if not await af.is_file():
|
||||
continue
|
||||
candidates.append((Path(f).as_posix(), (await af.stat()).st_size))
|
||||
except OSError, PermissionError:
|
||||
except (OSError, PermissionError):
|
||||
_bluray_probe_file_cache[cache_key] = None
|
||||
return None
|
||||
|
||||
|
||||
@@ -99,7 +99,7 @@ async def get_added_timestamp(path: Path) -> Optional[int]:
|
||||
ap = AsyncPath(path)
|
||||
try:
|
||||
stat_info = await ap.stat()
|
||||
except OSError, PermissionError:
|
||||
except (OSError, PermissionError):
|
||||
return None
|
||||
|
||||
if await ap.is_dir():
|
||||
@@ -124,7 +124,7 @@ async def get_directory_size(path: Path) -> int:
|
||||
for item in ap.rglob("*"):
|
||||
if await AsyncPath(item).is_file():
|
||||
total += (await AsyncPath(item).stat()).st_size
|
||||
except OSError, PermissionError:
|
||||
except (OSError, PermissionError):
|
||||
pass
|
||||
return total
|
||||
|
||||
|
||||
@@ -48,9 +48,10 @@ class IndexStore:
|
||||
# This would make IndexStore testable without FastAPI's WebSocket.
|
||||
"""
|
||||
|
||||
def __init__(self, snapshot_path: Path, media_root: Optional[str] = None):
|
||||
def __init__(self, snapshot_path: Path, media_root: Optional[str] = None, root_id: Optional[str] = None):
|
||||
self.snapshot_path = snapshot_path
|
||||
self.media_root = media_root
|
||||
self.root_id = root_id
|
||||
|
||||
# The index: keyed by item id
|
||||
self.movies: dict[str, Movie] = {}
|
||||
@@ -67,6 +68,14 @@ class IndexStore:
|
||||
# Persistence
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def _maybe_migrate_id(self, item_id: str) -> str:
|
||||
"""Prepend root_id to legacy item IDs that lack it."""
|
||||
if not self.root_id:
|
||||
return item_id
|
||||
if ":" in item_id:
|
||||
return item_id
|
||||
return f"{self.root_id}:{item_id}"
|
||||
|
||||
async def load_snapshot(self) -> None:
|
||||
"""Load index from disk snapshot (recovery on startup)."""
|
||||
ap = AsyncPath(self.snapshot_path)
|
||||
@@ -110,6 +119,8 @@ class IndexStore:
|
||||
m.showreel_source_sets = (
|
||||
[[p] for p in filtered_images] if filtered_images else None
|
||||
)
|
||||
m.id = self._maybe_migrate_id(m.id)
|
||||
m.root_id = self.root_id
|
||||
self.movies[m.id] = m
|
||||
for s in data.series:
|
||||
for season in s.seasons:
|
||||
@@ -139,6 +150,8 @@ class IndexStore:
|
||||
else:
|
||||
ep.reel_image = None
|
||||
ep.reel_sources = None
|
||||
s.id = self._maybe_migrate_id(s.id)
|
||||
s.root_id = self.root_id
|
||||
self.series[s.id] = s
|
||||
logger.info(
|
||||
"Loaded snapshot: %d movies, %d series",
|
||||
@@ -193,6 +206,8 @@ class IndexStore:
|
||||
|
||||
def upsert_movie(self, item: Movie) -> bool:
|
||||
"""Insert or update a movie. Returns True if it was a real change."""
|
||||
if not item.root_id and self.root_id:
|
||||
item.root_id = self.root_id
|
||||
existing = self.movies.get(item.id)
|
||||
if existing is not None:
|
||||
if msgspec.json.encode(existing) == msgspec.json.encode(item):
|
||||
@@ -204,6 +219,8 @@ class IndexStore:
|
||||
|
||||
def upsert_series(self, item: Series) -> bool:
|
||||
"""Insert or update a series. Returns True if it was a real change."""
|
||||
if not item.root_id and self.root_id:
|
||||
item.root_id = self.root_id
|
||||
existing = self.series.get(item.id)
|
||||
if existing is not None:
|
||||
if msgspec.json.encode(existing) == msgspec.json.encode(item):
|
||||
|
||||
@@ -76,6 +76,7 @@ class Movie(msgspec.Struct):
|
||||
showreel_images: list[str] | None = None
|
||||
showreel_source_sets: list[list[str]] | None = None
|
||||
torrents: dict[str, Torrent] = {}
|
||||
root_id: str | None = None
|
||||
|
||||
|
||||
class Series(msgspec.Struct):
|
||||
@@ -89,6 +90,7 @@ class Series(msgspec.Struct):
|
||||
cover_path: str | None = None
|
||||
backdrop_path: str | None = None
|
||||
seasons: list[Season] = []
|
||||
root_id: str | None = None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
"""
|
||||
Protocol structures for API and WebSocket communication.
|
||||
"""Protocol structures for API and WebSocket communication.
|
||||
|
||||
All types are msgspec.Structs for fast serialization.
|
||||
"""
|
||||
@@ -52,37 +51,41 @@ __all__ = [
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class ScanRequest(msgspec.Struct):
|
||||
"""POST /api/scan body."""
|
||||
|
||||
paths: list[str] | None = None
|
||||
|
||||
|
||||
class StatusResponse(msgspec.Struct):
|
||||
"""GET /api/status response."""
|
||||
|
||||
scanning: bool = False
|
||||
movies: int = 0
|
||||
series: int = 0
|
||||
showreel_queue: int = 0
|
||||
|
||||
|
||||
class PlayMediaRequest(msgspec.Struct):
|
||||
"""POST /api/play body (mediahive server)."""
|
||||
"""POST /api/roots/{root_id}/play body."""
|
||||
|
||||
file_path: str = ""
|
||||
|
||||
|
||||
class OpenFolderRequest(msgspec.Struct):
|
||||
"""POST /api/open-folder body (mediahive server)."""
|
||||
"""POST /api/roots/{root_id}/open-folder body."""
|
||||
|
||||
folder_path: str = ""
|
||||
|
||||
|
||||
class ChangeFolderRequest(msgspec.Struct):
|
||||
"""POST /api/change-folder body."""
|
||||
class RootsRequest(msgspec.Struct):
|
||||
"""PUT /api/roots body."""
|
||||
|
||||
folder: str
|
||||
roots: dict[str, str]
|
||||
|
||||
|
||||
class RootEntryResponse(msgspec.Struct):
|
||||
"""Single root entry in responses."""
|
||||
|
||||
name: str
|
||||
path: str
|
||||
root_id: str
|
||||
|
||||
|
||||
class RootStatusResponse(msgspec.Struct):
|
||||
"""Per-root status in GET /api/roots."""
|
||||
|
||||
root_id: str
|
||||
path: str
|
||||
status: str
|
||||
error: str | None = None
|
||||
movies: int = 0
|
||||
series: int = 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@@ -0,0 +1,295 @@
|
||||
"""Root registry, per-root context, and supervisor for multi-root media support."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
import msgspec
|
||||
|
||||
from mediahive.config import load_config, save_config
|
||||
from mediahive.index_store import IndexStore
|
||||
from mediahive.models.events import ScanEvent, Task, Upsert
|
||||
from mediahive.models.data import TaskInfo
|
||||
|
||||
logger = logging.getLogger("mediahive.root_registry")
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Root ID
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _normalize_path(path: str) -> str:
|
||||
"""Canonicalize a path for stable ID generation.
|
||||
|
||||
- resolve() to follow symlinks and normalize ..
|
||||
- lower-case drive letter on Windows
|
||||
- strip trailing separators
|
||||
- use forward slashes
|
||||
"""
|
||||
p = Path(path).expanduser().resolve()
|
||||
posix = p.as_posix()
|
||||
# Windows drive letter normalization
|
||||
if len(posix) >= 2 and posix[1] == ":":
|
||||
posix = posix[0].lower() + posix[1:]
|
||||
# Strip trailing slash (except root "/")
|
||||
while len(posix) > 1 and posix.endswith("/"):
|
||||
posix = posix[:-1]
|
||||
return posix
|
||||
|
||||
|
||||
def compute_root_id(path: str) -> str:
|
||||
"""Return a stable 12-char hex root ID from a normalized path."""
|
||||
normalized = _normalize_path(path)
|
||||
h = hashlib.sha256(normalized.encode("utf-8")).hexdigest()
|
||||
return h[:12]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Root entry
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class RootEntry(msgspec.Struct):
|
||||
name: str
|
||||
path: str
|
||||
root_id: str
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Root context
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class RootContext:
|
||||
"""Runtime container for a single media root."""
|
||||
|
||||
def __init__(self, root_id: str, root_path: Path):
|
||||
self.root_id = root_id
|
||||
self.root_path = root_path
|
||||
self.status = "loading"
|
||||
self.error: Optional[str] = None
|
||||
|
||||
snapshot_path = root_path / ".mediahive" / "index.json"
|
||||
self.store = IndexStore(snapshot_path, media_root=root_path.as_posix(), root_id=root_id)
|
||||
|
||||
# Scanner is injected later by the supervisor
|
||||
self.scanner: Optional[object] = None
|
||||
|
||||
# Event queue and consumer
|
||||
self._events: asyncio.Queue[ScanEvent] = asyncio.Queue()
|
||||
self._consumer_task: Optional[asyncio.Task] = None
|
||||
|
||||
async def start(self) -> None:
|
||||
"""Load snapshot and start event consumer."""
|
||||
try:
|
||||
await self.store.load_snapshot()
|
||||
self.status = "ready"
|
||||
logger.info(
|
||||
"Root %s ready: %d movies, %d series",
|
||||
self.root_id,
|
||||
len(self.store.movies),
|
||||
len(self.store.series),
|
||||
)
|
||||
except Exception as exc:
|
||||
self.status = "error"
|
||||
self.error = str(exc)
|
||||
logger.exception("Root %s failed to load snapshot", self.root_id)
|
||||
|
||||
self._consumer_task = asyncio.create_task(self._consume_events())
|
||||
|
||||
async def stop(self) -> None:
|
||||
"""Stop consumer, flush snapshot, stop scanner."""
|
||||
if self.scanner is not None:
|
||||
try:
|
||||
await self.scanner.stop()
|
||||
except Exception:
|
||||
logger.exception("Error stopping scanner for root %s", self.root_id)
|
||||
self.scanner = None
|
||||
|
||||
if self._consumer_task and not self._consumer_task.done():
|
||||
self._consumer_task.cancel()
|
||||
try:
|
||||
await self._consumer_task
|
||||
except asyncio.CancelledError:
|
||||
pass
|
||||
|
||||
try:
|
||||
await self.store.flush_snapshot()
|
||||
except Exception:
|
||||
logger.exception("Error flushing snapshot for root %s", self.root_id)
|
||||
|
||||
async def send_event(self, event: ScanEvent) -> None:
|
||||
"""Called by the scanner to push an event into this root's queue."""
|
||||
await self._events.put(event)
|
||||
|
||||
async def _consume_events(self) -> None:
|
||||
while True:
|
||||
try:
|
||||
event = await self._events.get()
|
||||
if isinstance(event, Upsert):
|
||||
if event.kind == "movie":
|
||||
self.store.upsert_movie(event.item)
|
||||
else:
|
||||
self.store.upsert_series(event.item)
|
||||
elif isinstance(event, Task):
|
||||
self.store.broadcast_task(event.data)
|
||||
except asyncio.CancelledError:
|
||||
return
|
||||
except Exception:
|
||||
logger.exception("Error processing scan event for root %s", self.root_id)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Supervisor
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class Supervisor:
|
||||
"""Manages the active set of RootContexts and handles atomic replacement."""
|
||||
|
||||
def __init__(self):
|
||||
# Active contexts keyed by root_id
|
||||
self._contexts: dict[str, RootContext] = {}
|
||||
self._lock = asyncio.Lock()
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Read helpers
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def get(self, root_id: str) -> Optional[RootContext]:
|
||||
return self._contexts.get(root_id)
|
||||
|
||||
def all_contexts(self) -> dict[str, RootContext]:
|
||||
return self._contexts.copy()
|
||||
|
||||
def all_statuses(self) -> list[dict]:
|
||||
return [
|
||||
{
|
||||
"root_id": ctx.root_id,
|
||||
"path": ctx.root_path.as_posix(),
|
||||
"status": ctx.status,
|
||||
"error": ctx.error,
|
||||
"movies": len(ctx.store.movies),
|
||||
"series": len(ctx.store.series),
|
||||
}
|
||||
for ctx in self._contexts.values()
|
||||
]
|
||||
|
||||
def merged_index(self) -> dict:
|
||||
"""Return a merged index snapshot from all ready roots."""
|
||||
movies = []
|
||||
series = []
|
||||
total_movie_versions = 0
|
||||
total_series_episodes = 0
|
||||
for ctx in self._contexts.values():
|
||||
if ctx.status != "ready" and ctx.status != "scanning":
|
||||
continue
|
||||
movies.extend(ctx.store.movies.values())
|
||||
series.extend(ctx.store.series.values())
|
||||
total_movie_versions += sum(len(m.torrents) for m in ctx.store.movies.values())
|
||||
total_series_episodes += sum(
|
||||
sum(len(season.episodes) for season in s.seasons)
|
||||
for s in ctx.store.series.values()
|
||||
)
|
||||
|
||||
from datetime import datetime
|
||||
from mediahive.models.data import IndexSnapshot, MediaStats
|
||||
|
||||
return {
|
||||
"version": 7,
|
||||
"generated_at": datetime.now().isoformat(),
|
||||
"stats": {
|
||||
"total_movies": len(movies),
|
||||
"total_movie_versions": total_movie_versions,
|
||||
"total_series": len(series),
|
||||
"total_series_episodes": total_series_episodes,
|
||||
},
|
||||
"movies": movies,
|
||||
"series": series,
|
||||
}
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Atomic replacement
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
async def replace_roots(self, roots: dict[str, str]) -> tuple[list[RootEntry], list[dict]]:
|
||||
"""Atomically replace the active root set.
|
||||
|
||||
Returns (accepted_entries, failed_entries_with_reason).
|
||||
"""
|
||||
async with self._lock:
|
||||
# Validate and canonicalize
|
||||
candidates: list[RootEntry] = []
|
||||
seen_paths: set[str] = set()
|
||||
seen_ids: set[str] = set()
|
||||
failed: list[dict] = []
|
||||
|
||||
for name, path_str in roots.items():
|
||||
name = name.strip()
|
||||
if not name:
|
||||
failed.append({"name": name, "path": path_str, "reason": "empty name"})
|
||||
continue
|
||||
p = Path(path_str).expanduser().resolve()
|
||||
if not p.exists() or not p.is_dir():
|
||||
failed.append({"name": name, "path": path_str, "reason": "not a directory"})
|
||||
continue
|
||||
norm = _normalize_path(p.as_posix())
|
||||
if norm in seen_paths:
|
||||
failed.append({"name": name, "path": path_str, "reason": "duplicate path"})
|
||||
continue
|
||||
seen_paths.add(norm)
|
||||
rid = compute_root_id(str(p))
|
||||
if rid in seen_ids:
|
||||
# Extremely unlikely hash collision — fall back to full hash
|
||||
rid = hashlib.sha256(norm.encode("utf-8")).hexdigest()[:16]
|
||||
seen_ids.add(rid)
|
||||
candidates.append(RootEntry(name=name, path=norm, root_id=rid))
|
||||
|
||||
# Build desired root_id set
|
||||
desired_ids = {e.root_id for e in candidates}
|
||||
|
||||
# Stop scanners for roots that are being removed or changed
|
||||
old_contexts = list(self._contexts.values())
|
||||
for ctx in old_contexts:
|
||||
if ctx.root_id not in desired_ids:
|
||||
asyncio.create_task(ctx.stop())
|
||||
|
||||
# Prepare new contexts
|
||||
new_contexts: dict[str, RootContext] = {}
|
||||
for entry in candidates:
|
||||
existing = self._contexts.get(entry.root_id)
|
||||
if existing and existing.root_path.as_posix() == entry.path:
|
||||
# Reuse existing context
|
||||
new_contexts[entry.root_id] = existing
|
||||
else:
|
||||
# If existing path changed, stop old one
|
||||
if existing:
|
||||
asyncio.create_task(existing.stop())
|
||||
ctx = RootContext(entry.root_id, Path(entry.path))
|
||||
await ctx.start()
|
||||
new_contexts[entry.root_id] = ctx
|
||||
|
||||
# Atomic swap
|
||||
self._contexts = new_contexts
|
||||
|
||||
# Persist to config
|
||||
cfg = load_config()
|
||||
save_config(
|
||||
msgspec.structs.replace(
|
||||
cfg,
|
||||
roots={e.name: e.path for e in candidates},
|
||||
)
|
||||
)
|
||||
|
||||
return candidates, failed
|
||||
|
||||
async def shutdown(self) -> None:
|
||||
async with self._lock:
|
||||
for ctx in list(self._contexts.values()):
|
||||
await ctx.stop()
|
||||
self._contexts.clear()
|
||||
+240
-286
@@ -6,6 +6,8 @@ pipeline with live WebSocket updates. Excluded paths are controlled by
|
||||
``.mediahive/scanignore`` (gitignore-style syntax).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
@@ -22,25 +24,21 @@ from pathlib import Path
|
||||
|
||||
import aiofiles
|
||||
import msgspec
|
||||
import msgspec.structs
|
||||
from fastapi import FastAPI, HTTPException, Request, WebSocket, WebSocketDisconnect
|
||||
from fastapi.middleware.cors import CORSMiddleware
|
||||
from fastapi.responses import FileResponse, StreamingResponse
|
||||
from fastapi_vue import Frontend
|
||||
|
||||
from mediahive.__main__ import DEVMODE
|
||||
from mediahive.config import load_config, save_config
|
||||
from mediahive.hivescan.scanner import start as start_scanner
|
||||
from mediahive.hivescan.scanner import stop as stop_scanner
|
||||
from mediahive.index_store import IndexStore
|
||||
from mediahive.models.events import ScanEvent, Task, Upsert
|
||||
from mediahive.config import load_config
|
||||
from mediahive.hivescan.scanner import RootScanner
|
||||
from mediahive.models.protocol import (
|
||||
ChangeFolderRequest,
|
||||
MsgspecResponse,
|
||||
OpenFolderRequest,
|
||||
PlayMediaRequest,
|
||||
StatusResponse,
|
||||
RootsRequest,
|
||||
)
|
||||
from mediahive.root_registry import Supervisor, compute_root_id
|
||||
|
||||
logger = logging.getLogger("mediahive.server")
|
||||
|
||||
@@ -54,35 +52,49 @@ _POPEN_KWARGS: dict = (
|
||||
# Vue Frontend static files
|
||||
frontend = Frontend(Path(__file__).with_name("frontend-build"), cached=["/assets/"])
|
||||
|
||||
# Media root path (initialized in lifespan)
|
||||
MEDIAROOT = None
|
||||
# Supervisor manages all root contexts
|
||||
supervisor = Supervisor()
|
||||
|
||||
# In-memory index store (available immediately, switched to real root later)
|
||||
_BOOTSTRAP_SNAPSHOT = Path(tempfile.gettempdir()) / "mediahive" / "index.json"
|
||||
store: IndexStore = IndexStore(_BOOTSTRAP_SNAPSHOT, media_root=None)
|
||||
|
||||
# Whether the scanner subsystem is active
|
||||
_scanner_active = False
|
||||
|
||||
# Background folder switch task and lock so startup/change-folder cannot race
|
||||
_folder_switch_task: asyncio.Task | None = None
|
||||
_folder_switch_lock = asyncio.Lock()
|
||||
|
||||
# Queue for scanner → server events
|
||||
_scan_events: asyncio.Queue[ScanEvent] = asyncio.Queue()
|
||||
_consumer_task: asyncio.Task | None = None
|
||||
_RANGE_RE = re.compile(r"bytes=(\d*)-(\d*)$")
|
||||
|
||||
|
||||
def _require_media_root() -> Path:
|
||||
if MEDIAROOT is None:
|
||||
raise HTTPException(status_code=503, detail="Media root not initialized yet")
|
||||
return MEDIAROOT
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
async def _send_event(event: ScanEvent) -> None:
|
||||
"""Push a scan event onto the queue (passed to hivescan as *send*)."""
|
||||
await _scan_events.put(event)
|
||||
def _get_context(root_id: str):
|
||||
ctx = supervisor.get(root_id)
|
||||
if ctx is None:
|
||||
raise HTTPException(status_code=404, detail=f"Root not found: {root_id}")
|
||||
return ctx
|
||||
|
||||
|
||||
def _load_resume_positions(root_path: Path) -> dict[str, int]:
|
||||
playback_state_path = root_path / ".mediahive" / "playback-state.json"
|
||||
try:
|
||||
raw = json.loads(playback_state_path.read_text(encoding="utf-8"))
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
resume_positions = raw.get("resume_positions") if isinstance(raw, dict) else None
|
||||
if not isinstance(resume_positions, dict):
|
||||
return {}
|
||||
|
||||
cleaned: dict[str, int] = {}
|
||||
for key, value in resume_positions.items():
|
||||
if isinstance(key, str) and isinstance(value, (int, float)):
|
||||
cleaned[key] = max(0, int(value))
|
||||
return cleaned
|
||||
|
||||
|
||||
def _open_with_default_app(path: Path) -> None:
|
||||
if sys.platform == "win32":
|
||||
os.startfile(str(path))
|
||||
return
|
||||
|
||||
opener = "open" if sys.platform == "darwin" else "xdg-open"
|
||||
subprocess.Popen([opener, str(path)], **_POPEN_KWARGS)
|
||||
|
||||
|
||||
def _parse_range_header(range_header: str, file_size: int) -> tuple[int, int]:
|
||||
@@ -127,70 +139,103 @@ def _parse_range_header(range_header: str, file_size: int) -> tuple[int, int]:
|
||||
return start, min(end, file_size - 1)
|
||||
|
||||
|
||||
async def _consume_scan_events() -> None:
|
||||
"""Background task: apply incoming scan events to the IndexStore."""
|
||||
while True:
|
||||
def _validate_root_paths(roots: dict[str, str]) -> dict[str, str]:
|
||||
"""Validate root paths on the filesystem.
|
||||
|
||||
Runs in a thread pool so macOS permission dialogs (and other blocking
|
||||
filesystem checks) do not halt the asyncio event loop.
|
||||
"""
|
||||
validated: dict[str, str] = {}
|
||||
for name, path_str in roots.items():
|
||||
p = Path(path_str).expanduser().resolve()
|
||||
if not p.exists() or not p.is_dir():
|
||||
logger.warning("Root path invalid, skipping: %s", path_str)
|
||||
continue
|
||||
validated[name] = p.as_posix()
|
||||
return validated
|
||||
|
||||
|
||||
async def _attach_scanners() -> None:
|
||||
"""Ensure every active root context has a running scanner."""
|
||||
for ctx in supervisor.all_contexts().values():
|
||||
if ctx.scanner is None and ctx.status in ("ready", "loading"):
|
||||
try:
|
||||
scanner = RootScanner(ctx.root_id, ctx.root_path, ctx.send_event)
|
||||
await scanner.start()
|
||||
ctx.scanner = scanner
|
||||
except Exception:
|
||||
logger.exception("Failed to attach scanner for root %s", ctx.root_id)
|
||||
|
||||
|
||||
async def _activate_all_roots() -> None:
|
||||
"""Background task: validate and activate all configured roots.
|
||||
|
||||
This is deferred from lifespan startup so the server can begin accepting
|
||||
requests immediately. Filesystem validation runs in a thread pool to avoid
|
||||
blocking the event loop (and to let macOS permission dialogs appear without
|
||||
stalling the server).
|
||||
"""
|
||||
desired: dict[str, str] = {}
|
||||
|
||||
# 1. Persisted config roots
|
||||
cfg = load_config()
|
||||
if cfg.roots:
|
||||
desired.update(cfg.roots)
|
||||
|
||||
# 2. CLI roots via MEDIAHIVE_ROOTS (JSON dict)
|
||||
env_roots_raw = os.environ.get("MEDIAHIVE_ROOTS")
|
||||
if env_roots_raw:
|
||||
try:
|
||||
event = await _scan_events.get()
|
||||
if isinstance(event, Upsert):
|
||||
if event.kind == "movie":
|
||||
store.upsert_movie(event.item)
|
||||
else:
|
||||
store.upsert_series(event.item)
|
||||
elif isinstance(event, Task):
|
||||
store.broadcast_task(event.data)
|
||||
except asyncio.CancelledError:
|
||||
return
|
||||
env_roots = json.loads(env_roots_raw)
|
||||
if isinstance(env_roots, dict):
|
||||
desired.update(env_roots)
|
||||
except Exception:
|
||||
logger.exception("Error processing scan event")
|
||||
logger.exception("Failed to parse MEDIAHIVE_ROOTS")
|
||||
|
||||
if not desired:
|
||||
logger.info("No roots configured; waiting for PUT /api/roots")
|
||||
return
|
||||
|
||||
# Validate paths in a thread pool (macOS permission-dialog safe)
|
||||
validated = await asyncio.to_thread(_validate_root_paths, desired)
|
||||
if not validated:
|
||||
logger.warning("No valid roots found after validation")
|
||||
return
|
||||
|
||||
try:
|
||||
await supervisor.replace_roots(validated)
|
||||
except Exception:
|
||||
logger.exception("Failed to replace roots during background activation")
|
||||
return
|
||||
|
||||
await _attach_scanners()
|
||||
logger.info("Background root activation complete; %d root(s) active", len(supervisor.all_contexts()))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Lifespan
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
global MEDIAROOT, store, _scanner_active, _consumer_task, _folder_switch_task
|
||||
|
||||
await frontend.load()
|
||||
|
||||
# Bring up the API immediately with an empty in-memory store.
|
||||
# Media-root initialization/scanner startup are deferred to a background task
|
||||
# so macOS permission prompts cannot block server readiness.
|
||||
store = IndexStore(_BOOTSTRAP_SNAPSHOT, media_root=None)
|
||||
await store.load_snapshot()
|
||||
_scanner_active = False
|
||||
# Defer root activation to a background task so the server starts
|
||||
# immediately and macOS permission dialogs do not block startup.
|
||||
activation_task = asyncio.create_task(_activate_all_roots())
|
||||
|
||||
initial_root_raw = os.environ.get("MEDIAHIVE_PATH")
|
||||
defer_initial_root = os.environ.get("MEDIAHIVE_DEFER_INITIAL_ROOT") == "1"
|
||||
|
||||
if initial_root_raw and not defer_initial_root:
|
||||
initial_root = Path(initial_root_raw).expanduser()
|
||||
if not initial_root.is_absolute():
|
||||
initial_root = Path.cwd() / initial_root
|
||||
_folder_switch_task = asyncio.create_task(_switch_folder(initial_root))
|
||||
logger.info("Server started; scheduled initial media root activation")
|
||||
else:
|
||||
logger.info(
|
||||
"Server started without active media root; waiting for folder activation"
|
||||
)
|
||||
logger.info("Server ready; waiting for root activation")
|
||||
|
||||
yield
|
||||
|
||||
# Shutdown
|
||||
if _folder_switch_task and not _folder_switch_task.done():
|
||||
_folder_switch_task.cancel()
|
||||
try:
|
||||
await _folder_switch_task
|
||||
except asyncio.CancelledError:
|
||||
pass
|
||||
activation_task.cancel()
|
||||
try:
|
||||
await activation_task
|
||||
except asyncio.CancelledError:
|
||||
pass
|
||||
|
||||
await stop_scanner()
|
||||
_scanner_active = False
|
||||
if _consumer_task:
|
||||
_consumer_task.cancel()
|
||||
try:
|
||||
await _consumer_task
|
||||
except asyncio.CancelledError:
|
||||
pass
|
||||
await store.flush_snapshot()
|
||||
await supervisor.shutdown()
|
||||
|
||||
|
||||
app = FastAPI(title="MediaHive Server", lifespan=lifespan, debug=DEVMODE)
|
||||
@@ -205,44 +250,9 @@ app.add_middleware(
|
||||
)
|
||||
|
||||
|
||||
def normalize_path(url_path: str) -> Path:
|
||||
"""
|
||||
Convert URL path to filesystem path.
|
||||
URL: /media/.mediahive/Movies/...
|
||||
Returns: MEDIAROOT/.mediahive/Movies/...
|
||||
"""
|
||||
clean_path = url_path.lstrip("/")
|
||||
return _require_media_root() / clean_path
|
||||
|
||||
|
||||
def _load_resume_positions() -> dict[str, int]:
|
||||
playback_state_path = _require_media_root() / ".mediahive" / "playback-state.json"
|
||||
try:
|
||||
raw = json.loads(playback_state_path.read_text(encoding="utf-8"))
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
resume_positions = raw.get("resume_positions") if isinstance(raw, dict) else None
|
||||
if not isinstance(resume_positions, dict):
|
||||
return {}
|
||||
|
||||
cleaned: dict[str, int] = {}
|
||||
for key, value in resume_positions.items():
|
||||
if isinstance(key, str) and isinstance(value, (int, float)):
|
||||
cleaned[key] = max(0, int(value))
|
||||
return cleaned
|
||||
|
||||
|
||||
def _open_with_default_app(path: Path) -> None:
|
||||
if sys.platform == "win32":
|
||||
os.startfile(str(path))
|
||||
return
|
||||
|
||||
opener = "open" if sys.platform == "darwin" else "xdg-open"
|
||||
subprocess.Popen([opener, str(path)], **_POPEN_KWARGS)
|
||||
|
||||
|
||||
# === API Endpoints ===
|
||||
# ---------------------------------------------------------------------------
|
||||
# API Endpoints
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@app.get("/api/health")
|
||||
@@ -254,179 +264,120 @@ async def health_check():
|
||||
@app.get("/api/config")
|
||||
async def get_config():
|
||||
"""Return current server configuration."""
|
||||
return {"media_folder": MEDIAROOT.as_posix() if MEDIAROOT else None}
|
||||
|
||||
|
||||
@app.post("/api/change-folder")
|
||||
async def change_folder_endpoint(request: Request):
|
||||
"""Switch the media root folder without restarting the server.
|
||||
|
||||
Validates and persists the new folder, then returns immediately.
|
||||
The actual in-memory switch runs as a background task so the HTTP
|
||||
response is not held up by the (potentially slow) scanner teardown.
|
||||
The client should poll /api/config or reload after a short delay.
|
||||
"""
|
||||
body = msgspec.json.decode(await request.body(), type=ChangeFolderRequest)
|
||||
new_root = Path(body.folder).resolve()
|
||||
if not new_root.exists() or not new_root.is_dir():
|
||||
raise HTTPException(
|
||||
status_code=400, detail=f"Folder does not exist: {new_root}"
|
||||
)
|
||||
|
||||
# Persist first — if the background switch crashes, the next launch still uses the new path
|
||||
cfg = load_config()
|
||||
save_config(msgspec.structs.replace(cfg, media_folder=new_root.as_posix()))
|
||||
logger.info("Config saved: media_folder=%s", new_root)
|
||||
|
||||
# Schedule the in-memory switch without blocking this response
|
||||
asyncio.create_task(_switch_folder(new_root))
|
||||
return {"status": "ok"}
|
||||
return {"roots": cfg.roots}
|
||||
|
||||
|
||||
async def _switch_folder(new_root: Path) -> None:
|
||||
global MEDIAROOT, store, _consumer_task, _scan_events, _scanner_active
|
||||
|
||||
async with _folder_switch_lock:
|
||||
try:
|
||||
# Cancel scanner tasks immediately — no need to wait 30 s
|
||||
await stop_scanner()
|
||||
_scanner_active = False
|
||||
|
||||
# Tear down the old event consumer
|
||||
if _consumer_task and not _consumer_task.done():
|
||||
_consumer_task.cancel()
|
||||
try:
|
||||
await _consumer_task
|
||||
except asyncio.CancelledError:
|
||||
pass
|
||||
|
||||
# Flush the old index snapshot
|
||||
await store.flush_snapshot()
|
||||
|
||||
# Update env and module globals
|
||||
os.environ["MEDIAHIVE_PATH"] = new_root.as_posix()
|
||||
MEDIAROOT = new_root
|
||||
|
||||
# Fresh event queue — discard any stale events from the old folder
|
||||
_scan_events = asyncio.Queue()
|
||||
|
||||
# Re-initialise the index store
|
||||
snapshot_path = MEDIAROOT / ".mediahive" / "index.json"
|
||||
store = IndexStore(snapshot_path, media_root=MEDIAROOT.as_posix())
|
||||
await store.load_snapshot()
|
||||
logger.info(
|
||||
"Index store ready: %d movies, %d series",
|
||||
len(store.movies),
|
||||
len(store.series),
|
||||
)
|
||||
|
||||
# Restart consumer and scanner
|
||||
_consumer_task = asyncio.create_task(_consume_scan_events())
|
||||
await start_scanner(_send_event)
|
||||
_scanner_active = True
|
||||
|
||||
logger.info("Switched media folder to %s", MEDIAROOT)
|
||||
except Exception:
|
||||
logger.exception("Error switching media folder to %s", new_root)
|
||||
# --- Root management ---
|
||||
|
||||
|
||||
@app.get("/api/index")
|
||||
async def get_index():
|
||||
"""Return the full media index from the in-memory store."""
|
||||
return MsgspecResponse(store.get_full_index())
|
||||
@app.get("/api/roots")
|
||||
async def get_roots():
|
||||
"""List all active roots with their status."""
|
||||
return {"roots": supervisor.all_statuses()}
|
||||
|
||||
|
||||
@app.get("/api/playback/resume-positions")
|
||||
async def playback_resume_positions():
|
||||
"""Return saved per-file resume positions under the current media root."""
|
||||
return {"resume_positions": _load_resume_positions()}
|
||||
@app.put("/api/roots")
|
||||
async def put_roots(request: Request):
|
||||
"""Atomically replace the full root set."""
|
||||
body = msgspec.json.decode(await request.body(), type=RootsRequest)
|
||||
accepted, failed = await supervisor.replace_roots(body.roots)
|
||||
|
||||
# Start scanners for newly accepted roots
|
||||
await _attach_scanners()
|
||||
|
||||
return {
|
||||
"status": "ok",
|
||||
"accepted": [
|
||||
{"name": e.name, "path": e.path, "root_id": e.root_id} for e in accepted
|
||||
],
|
||||
"failed": failed,
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Scanning API (active when HIVESCAN_PATHS is configured)
|
||||
# ---------------------------------------------------------------------------
|
||||
@app.get("/api/roots/{root_id}/index")
|
||||
async def get_root_index(root_id: str):
|
||||
"""Return the full index for a single root."""
|
||||
ctx = _get_context(root_id)
|
||||
return MsgspecResponse(ctx.store.get_full_index())
|
||||
|
||||
|
||||
@app.websocket("/api/ws")
|
||||
async def ws_endpoint(ws: WebSocket):
|
||||
"""Live index updates and task progress."""
|
||||
await store.connect(ws)
|
||||
@app.get("/api/roots/{root_id}/status")
|
||||
async def get_root_status(root_id: str):
|
||||
"""Return status for a single root."""
|
||||
ctx = _get_context(root_id)
|
||||
scanning = ctx.scanner is not None and ctx.scanner.is_scanning()
|
||||
return {
|
||||
"root_id": ctx.root_id,
|
||||
"path": ctx.root_path.as_posix(),
|
||||
"status": ctx.status,
|
||||
"error": ctx.error,
|
||||
"scanning": scanning,
|
||||
"movies": len(ctx.store.movies),
|
||||
"series": len(ctx.store.series),
|
||||
"showreel_queue": ctx.scanner.showreel_queue_size() if ctx.scanner else 0,
|
||||
}
|
||||
|
||||
|
||||
@app.post("/api/roots/{root_id}/scan")
|
||||
async def trigger_root_scan(root_id: str):
|
||||
"""Trigger a scan for a single root."""
|
||||
ctx = _get_context(root_id)
|
||||
if ctx.scanner is None:
|
||||
raise HTTPException(status_code=503, detail="Scanner not active")
|
||||
started = ctx.scanner.trigger_scan()
|
||||
return {"status": "started" if started else "already_running"}
|
||||
|
||||
|
||||
# --- Per-root WebSocket ---
|
||||
|
||||
|
||||
@app.websocket("/api/roots/{root_id}/ws")
|
||||
async def ws_endpoint(ws: WebSocket, root_id: str):
|
||||
"""Live index updates and task progress for a single root."""
|
||||
ctx = supervisor.get(root_id)
|
||||
if ctx is None:
|
||||
await ws.close(code=1008, reason="Unknown root")
|
||||
return
|
||||
|
||||
await ctx.store.connect(ws)
|
||||
try:
|
||||
while True:
|
||||
await ws.receive_text()
|
||||
except WebSocketDisconnect:
|
||||
store.disconnect(ws)
|
||||
ctx.store.disconnect(ws)
|
||||
except Exception:
|
||||
store.disconnect(ws)
|
||||
ctx.store.disconnect(ws)
|
||||
|
||||
|
||||
@app.post("/api/scan")
|
||||
async def trigger_scan():
|
||||
"""Trigger a new scan. Returns 409 if a scan is already running."""
|
||||
if not _scanner_active:
|
||||
raise HTTPException(status_code=503, detail="Scanner not active yet")
|
||||
from mediahive.hivescan.scanner import trigger_scan as _trigger
|
||||
|
||||
started = _trigger()
|
||||
return {"status": "started" if started else "already_running"}
|
||||
# --- Media actions ---
|
||||
|
||||
|
||||
@app.get("/api/status")
|
||||
async def server_status():
|
||||
"""Return current server status."""
|
||||
if _scanner_active:
|
||||
from mediahive.hivescan.scanner import is_scanning, showreel_queue_size
|
||||
|
||||
return MsgspecResponse(
|
||||
StatusResponse(
|
||||
scanning=is_scanning(),
|
||||
movies=len(store.movies),
|
||||
series=len(store.series),
|
||||
showreel_queue=showreel_queue_size(),
|
||||
)
|
||||
)
|
||||
return MsgspecResponse(
|
||||
StatusResponse(
|
||||
movies=len(store.movies),
|
||||
series=len(store.series),
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
@app.post("/api/play")
|
||||
async def play_media(request: Request):
|
||||
"""
|
||||
Open a media file with the system's default player.
|
||||
"""
|
||||
@app.post("/api/roots/{root_id}/play")
|
||||
async def play_media(root_id: str, request: Request):
|
||||
"""Open a media file with the system's default player."""
|
||||
ctx = _get_context(root_id)
|
||||
req = msgspec.json.decode(await request.body(), type=PlayMediaRequest)
|
||||
print(f"[play] Received path: {req.file_path}")
|
||||
file_path = _require_media_root() / req.file_path
|
||||
file_path = ctx.root_path / req.file_path
|
||||
|
||||
if not file_path.exists():
|
||||
print(f"[play] File not found: {file_path}")
|
||||
raise HTTPException(status_code=404, detail=f"File not found: {req.file_path}")
|
||||
|
||||
try:
|
||||
_open_with_default_app(file_path)
|
||||
|
||||
return {"status": "ok"}
|
||||
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=f"Failed to play media: {e}")
|
||||
|
||||
|
||||
@app.post("/api/open-folder")
|
||||
async def open_folder(request: Request):
|
||||
"""
|
||||
Open a folder in the system file explorer.
|
||||
If the path is a file, opens the parent folder and selects the file.
|
||||
"""
|
||||
@app.post("/api/roots/{root_id}/open-folder")
|
||||
async def open_folder(root_id: str, request: Request):
|
||||
"""Open a folder in the system file explorer."""
|
||||
ctx = _get_context(root_id)
|
||||
req = msgspec.json.decode(await request.body(), type=OpenFolderRequest)
|
||||
print(f"[open-folder] Received path: {req.folder_path}")
|
||||
target_path = _require_media_root() / req.folder_path
|
||||
target_path = ctx.root_path / req.folder_path
|
||||
|
||||
if not target_path.exists():
|
||||
print(f"[open-folder] Path not found: {target_path}")
|
||||
raise HTTPException(
|
||||
status_code=404, detail=f"Path not found: {req.folder_path}"
|
||||
)
|
||||
@@ -434,12 +385,10 @@ async def open_folder(request: Request):
|
||||
try:
|
||||
if sys.platform == "win32":
|
||||
if target_path.is_file():
|
||||
# Open parent folder and select the file
|
||||
subprocess.Popen(
|
||||
["explorer", "/select,", str(target_path)], **_POPEN_KWARGS
|
||||
)
|
||||
else:
|
||||
# Open the folder directly
|
||||
subprocess.Popen(["explorer", str(target_path)], **_POPEN_KWARGS)
|
||||
elif sys.platform == "darwin":
|
||||
if target_path.is_file():
|
||||
@@ -447,28 +396,22 @@ async def open_folder(request: Request):
|
||||
else:
|
||||
subprocess.Popen(["open", str(target_path)])
|
||||
else:
|
||||
# Linux - just open the folder (no standard way to select)
|
||||
folder = target_path.parent if target_path.is_file() else target_path
|
||||
subprocess.Popen(["xdg-open", str(folder)])
|
||||
|
||||
return {"status": "ok"}
|
||||
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=f"Failed to open folder: {e}")
|
||||
|
||||
|
||||
def _mpcbe_request(path: str, timeout: float = 0.75) -> bool:
|
||||
"""Call MPC-BE's local web interface and return True on HTTP success."""
|
||||
if sys.platform != "win32":
|
||||
return False
|
||||
@app.get("/api/roots/{root_id}/playback/resume-positions")
|
||||
async def root_playback_resume_positions(root_id: str):
|
||||
"""Return saved per-file resume positions under a specific root."""
|
||||
ctx = _get_context(root_id)
|
||||
return {"resume_positions": _load_resume_positions(ctx.root_path)}
|
||||
|
||||
url = f"{MPC_BE_BASE_URL}{path}"
|
||||
req = urllib.request.Request(url=url, method="GET")
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=timeout) as resp:
|
||||
return 200 <= resp.status < 300
|
||||
except urllib.error.URLError, TimeoutError, OSError:
|
||||
return False
|
||||
|
||||
# --- MPC-BE / Player status ---
|
||||
|
||||
|
||||
@app.get("/api/mpcbe/status")
|
||||
@@ -483,17 +426,32 @@ async def player_status():
|
||||
return {"remote": _mpcbe_request("/")}
|
||||
|
||||
|
||||
@app.get("/api/media/{file_path:path}")
|
||||
async def serve_media_file(file_path: str, request: Request):
|
||||
"""
|
||||
Serve a media file asynchronously.
|
||||
"""
|
||||
full_path = normalize_path(file_path)
|
||||
media_root = _require_media_root()
|
||||
def _mpcbe_request(path: str, timeout: float = 0.75) -> bool:
|
||||
"""Call MPC-BE's local web interface and return True on HTTP success."""
|
||||
if sys.platform != "win32":
|
||||
return False
|
||||
|
||||
url = f"{MPC_BE_BASE_URL}{path}"
|
||||
req = urllib.request.Request(url=url, method="GET")
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=timeout) as resp:
|
||||
return 200 <= resp.status < 300
|
||||
except (urllib.error.URLError, TimeoutError, OSError):
|
||||
return False
|
||||
|
||||
|
||||
# --- Media file serving ---
|
||||
|
||||
|
||||
@app.get("/api/media/{root_id}/{file_path:path}")
|
||||
async def serve_media_file(root_id: str, file_path: str, request: Request):
|
||||
"""Serve a media file asynchronously, scoped to a root."""
|
||||
ctx = _get_context(root_id)
|
||||
full_path = ctx.root_path / file_path.lstrip("/")
|
||||
|
||||
# Security: ensure path doesn't escape base
|
||||
try:
|
||||
full_path.resolve().relative_to(media_root.resolve())
|
||||
full_path.resolve().relative_to(ctx.root_path.resolve())
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=403, detail="Access denied")
|
||||
|
||||
@@ -505,19 +463,15 @@ async def serve_media_file(file_path: str, request: Request):
|
||||
|
||||
file_size = full_path.stat().st_size
|
||||
|
||||
# Guess content type
|
||||
content_type, _ = mimetypes.guess_type(str(full_path))
|
||||
if content_type is None:
|
||||
content_type = "application/octet-stream"
|
||||
|
||||
# For images, use FileResponse which handles caching headers
|
||||
if content_type.startswith("image/"):
|
||||
return FileResponse(
|
||||
full_path,
|
||||
media_type=content_type,
|
||||
headers={
|
||||
"Cache-Control": "public, max-age=86400",
|
||||
},
|
||||
headers={"Cache-Control": "public, max-age=86400"},
|
||||
)
|
||||
|
||||
async def stream_file(start: int, end: int):
|
||||
|
||||
+58
-41
@@ -154,12 +154,15 @@ def _save_playback_state(path: Path, state: dict[str, object]) -> None:
|
||||
tmp_path.replace(path)
|
||||
|
||||
|
||||
def _media_key_for_filepath(filepath: str, media_root: Path) -> str | None:
|
||||
try:
|
||||
relative = Path(filepath).resolve().relative_to(media_root.resolve())
|
||||
except Exception:
|
||||
return None
|
||||
return relative.as_posix()
|
||||
def _media_key_for_filepath(filepath: str, roots: list[Path]) -> tuple[str, Path] | None:
|
||||
"""Resolve a filepath to a (relative_key, matched_root) tuple."""
|
||||
for root in roots:
|
||||
try:
|
||||
relative = Path(filepath).resolve().relative_to(root.resolve())
|
||||
return relative.as_posix(), root
|
||||
except Exception:
|
||||
continue
|
||||
return None
|
||||
|
||||
|
||||
def _should_clear_resume(position_ms: int, duration_ms: int) -> bool:
|
||||
@@ -191,7 +194,7 @@ def _mpcbe_request(path: str, timeout: float = MPC_BE_REQUEST_TIMEOUT) -> bool:
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=timeout) as resp:
|
||||
return 200 <= resp.status < 300
|
||||
except urllib.error.URLError, TimeoutError, OSError:
|
||||
except (urllib.error.URLError, TimeoutError, OSError):
|
||||
return False
|
||||
|
||||
|
||||
@@ -222,7 +225,7 @@ def _mpcbe_fetch_status() -> tuple[str, int, int, int] | None:
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=MPC_BE_REQUEST_TIMEOUT) as resp:
|
||||
response_html = resp.read().decode("utf-8", errors="replace")
|
||||
except urllib.error.URLError, TimeoutError, OSError:
|
||||
except (urllib.error.URLError, TimeoutError, OSError):
|
||||
return None
|
||||
|
||||
state_match = _STATE_RE.search(response_html)
|
||||
@@ -242,7 +245,7 @@ def _mpcbe_fetch_status() -> tuple[str, int, int, int] | None:
|
||||
|
||||
|
||||
def _start_gamepad_remote(
|
||||
stop_event: threading.Event, media_root: Path
|
||||
stop_event: threading.Event, roots: list[Path]
|
||||
) -> threading.Thread:
|
||||
"""Start background XInput polling and send mapped commands to MPC-BE."""
|
||||
get_state = _load_xinput_get_state()
|
||||
@@ -273,7 +276,10 @@ def _start_gamepad_remote(
|
||||
player_state: int | None = None
|
||||
status_updated_at = 0.0
|
||||
status_miss_count = 0
|
||||
playback_state_path = media_root / ".mediahive" / "playback-state.json"
|
||||
|
||||
# Use the first root's playback state path as primary
|
||||
primary_root = roots[0] if roots else Path.cwd()
|
||||
playback_state_path = primary_root / ".mediahive" / "playback-state.json"
|
||||
playback_state = _load_playback_state(playback_state_path)
|
||||
resume_positions = playback_state["resume_positions"]
|
||||
if not isinstance(resume_positions, dict):
|
||||
@@ -429,7 +435,8 @@ def _start_gamepad_remote(
|
||||
status_miss_count = 0
|
||||
|
||||
filepath, position_ms, duration_ms, state = status
|
||||
media_key = _media_key_for_filepath(filepath, media_root) if filepath else None
|
||||
resolved = _media_key_for_filepath(filepath, roots) if filepath else None
|
||||
media_key = resolved[0] if resolved else None
|
||||
|
||||
if tracked_media_key is not None and media_key != tracked_media_key:
|
||||
finalize_tracked_current()
|
||||
@@ -676,7 +683,6 @@ def _icon_path() -> str | None:
|
||||
|
||||
def _webview_start_kwargs() -> dict[str, str]:
|
||||
"""Return platform-specific pywebview startup kwargs."""
|
||||
# On macOS, force Qt backend so pywebview uses Chromium/WebEngine instead of WKWebView.
|
||||
if sys.platform == "darwin":
|
||||
return {"gui": "qt"}
|
||||
return {}
|
||||
@@ -751,7 +757,7 @@ def winmain() -> None:
|
||||
parser.add_argument(
|
||||
"media_folder",
|
||||
nargs="?",
|
||||
help="Path to the media folder (default: saved config, MEDIAHIVE_PATH, or cwd)",
|
||||
help="Path to the media folder (default: saved config or initial setup dialog)",
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
@@ -761,33 +767,42 @@ def winmain() -> None:
|
||||
if getattr(sys, "frozen", False):
|
||||
_setup_logging()
|
||||
|
||||
# Resolution order: CLI arg → MEDIAHIVE_PATH env → saved config → ask user
|
||||
folder = (
|
||||
args.media_folder
|
||||
or os.environ.get("MEDIAHIVE_PATH")
|
||||
or load_config().media_folder
|
||||
)
|
||||
cfg = load_config()
|
||||
|
||||
if not folder:
|
||||
# Build initial roots dict (filesystem is NOT touched here — validation is
|
||||
# deferred to the server's background activation task).
|
||||
initial_roots: dict[str, str] = {}
|
||||
if args.media_folder:
|
||||
p = _normalize_media_root_input(args.media_folder)
|
||||
name = p.name or "media"
|
||||
initial_roots[name] = p.as_posix()
|
||||
elif cfg.roots:
|
||||
initial_roots = cfg.roots
|
||||
elif cfg.media_folder:
|
||||
p = _normalize_media_root_input(cfg.media_folder)
|
||||
name = p.name or "media"
|
||||
initial_roots[name] = p.as_posix()
|
||||
|
||||
if not initial_roots:
|
||||
folder = _run_initial_setup()
|
||||
if not folder:
|
||||
return # user cancelled the folder picker
|
||||
return # user cancelled
|
||||
p = _normalize_media_root_input(folder)
|
||||
name = p.name or "media"
|
||||
initial_roots[name] = p.as_posix()
|
||||
|
||||
mediaroot = _normalize_media_root_input(folder)
|
||||
os.environ["MEDIAHIVE_PATH"] = mediaroot.as_posix()
|
||||
os.environ["MEDIAHIVE_DEFER_INITIAL_ROOT"] = "1"
|
||||
# Persist resolved roots
|
||||
if cfg.roots != initial_roots:
|
||||
save_config(msgspec.structs.replace(cfg, roots=initial_roots))
|
||||
|
||||
# Pass roots to the server via env (validation deferred to server startup)
|
||||
os.environ["MEDIAHIVE_ROOTS"] = json.dumps(initial_roots)
|
||||
|
||||
backend_port = _reserve_backend_port()
|
||||
backend_url = f"http://{BACKEND_HOST}:{backend_port}"
|
||||
os.environ["MEDIAHIVE_BACKEND_URL"] = backend_url
|
||||
|
||||
# Persist the resolved path so subsequent launches remember it.
|
||||
cfg = load_config()
|
||||
if cfg.media_folder != mediaroot.as_posix():
|
||||
save_config(msgspec.structs.replace(cfg, media_folder=mediaroot.as_posix()))
|
||||
|
||||
# Run the FastAPI backend on a background thread so the main thread is
|
||||
# free for pywebview (Edge WebView2 requires the GUI on the main thread).
|
||||
# Run the FastAPI backend on a background thread
|
||||
config = uvicorn.Config(
|
||||
"mediahive.server:app",
|
||||
host=BACKEND_HOST,
|
||||
@@ -801,19 +816,19 @@ def winmain() -> None:
|
||||
)
|
||||
backend_thread.start()
|
||||
|
||||
def _activate_initial_folder() -> None:
|
||||
body = json.dumps({"folder": mediaroot.as_posix()}).encode("utf-8")
|
||||
def _activate_initial_roots() -> None:
|
||||
body = json.dumps({"roots": initial_roots}).encode("utf-8")
|
||||
req = urllib.request.Request(
|
||||
url=f"{backend_url}/api/change-folder",
|
||||
url=f"{backend_url}/api/roots",
|
||||
data=body,
|
||||
method="POST",
|
||||
method="PUT",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10):
|
||||
logger.info("Requested initial media folder activation")
|
||||
logger.info("Requested initial roots activation")
|
||||
except Exception as exc:
|
||||
logger.warning("Initial media folder activation request failed: %s", exc)
|
||||
logger.warning("Initial roots activation request failed: %s", exc)
|
||||
|
||||
if not _wait_for_backend(timeout=HEALTH_TIMEOUT):
|
||||
server.should_exit = True
|
||||
@@ -831,6 +846,9 @@ def winmain() -> None:
|
||||
poll_stop = threading.Event()
|
||||
poll_thread: threading.Thread | None = None
|
||||
|
||||
# Resolve all root paths for gamepad remote
|
||||
gamepad_roots = [Path(p) for p in initial_roots.values()]
|
||||
|
||||
def on_shown() -> None:
|
||||
api._window = window
|
||||
try:
|
||||
@@ -842,13 +860,12 @@ def winmain() -> None:
|
||||
|
||||
nonlocal poll_thread
|
||||
if poll_thread is None and _supports_gamepad_remote():
|
||||
poll_thread = _start_gamepad_remote(poll_stop, mediaroot)
|
||||
poll_thread = _start_gamepad_remote(poll_stop, gamepad_roots)
|
||||
|
||||
# Trigger initial folder activation after main UI is shown.
|
||||
threading.Thread(
|
||||
target=_activate_initial_folder,
|
||||
target=_activate_initial_roots,
|
||||
daemon=True,
|
||||
name="mediahive-initial-folder-activation",
|
||||
name="mediahive-initial-roots-activation",
|
||||
).start()
|
||||
|
||||
webview.start(func=on_shown, icon=_icon_path(), **_webview_start_kwargs())
|
||||
|
||||
Reference in New Issue
Block a user