initial commit
This commit is contained in:
Pierre
@@ -0,0 +1,66 @@
|
||||
name: Build and Push Docker Image
|
||||
|
||||
on:
|
||||
push:
|
||||
tags:
|
||||
- 'v*'
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
tag:
|
||||
description: 'Tag for the image (optional, defaults to sha)'
|
||||
required: false
|
||||
type: string
|
||||
meta_core_version:
|
||||
description: 'meta-core version to use (default: latest)'
|
||||
required: false
|
||||
type: string
|
||||
default: 'latest'
|
||||
|
||||
env:
|
||||
REGISTRY: ghcr.io
|
||||
IMAGE_NAME: ${{ github.repository }}
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
contents: read
|
||||
packages: write
|
||||
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Set up Docker Buildx
|
||||
uses: docker/setup-buildx-action@v3
|
||||
|
||||
- name: Log in to Container Registry
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
registry: ${{ env.REGISTRY }}
|
||||
username: ${{ github.actor }}
|
||||
password: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
- name: Extract metadata (tags, labels)
|
||||
id: meta
|
||||
uses: docker/metadata-action@v5
|
||||
with:
|
||||
images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
|
||||
tags: |
|
||||
type=semver,pattern={{version}}
|
||||
type=semver,pattern={{major}}.{{minor}}
|
||||
type=sha,prefix=
|
||||
type=raw,value=latest,enable={{is_default_branch}}
|
||||
type=raw,value=${{ inputs.tag }},enable=${{ inputs.tag != '' }}
|
||||
|
||||
- name: Build and push Docker image
|
||||
uses: docker/build-push-action@v5
|
||||
with:
|
||||
context: .
|
||||
push: true
|
||||
tags: ${{ steps.meta.outputs.tags }}
|
||||
labels: ${{ steps.meta.outputs.labels }}
|
||||
build-args: |
|
||||
META_CORE_IMAGE=ghcr.io/worph/meta-core:${{ inputs.meta_core_version || 'latest' }}
|
||||
cache-from: type=gha
|
||||
cache-to: type=gha,mode=max
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
# Python
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
*$py.class
|
||||
*.so
|
||||
.Python
|
||||
env/
|
||||
venv/
|
||||
.venv/
|
||||
*.egg-info/
|
||||
dist/
|
||||
build/
|
||||
|
||||
# IDE
|
||||
.idea/
|
||||
.vscode/
|
||||
*.swp
|
||||
*.swo
|
||||
|
||||
# Cache
|
||||
.cache/
|
||||
*.log
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
# Meta-Stremio Docker Image
|
||||
# Standalone Stremio addon with HLS transcoding and KV storage integration
|
||||
#
|
||||
# Build standalone:
|
||||
# docker build -t meta-stremio .
|
||||
#
|
||||
# Build with custom meta-core (for development):
|
||||
# docker build --build-arg META_CORE_IMAGE=meta-core:local -t meta-stremio .
|
||||
|
||||
# Stage 0: Get meta-core binary from published image
|
||||
ARG META_CORE_IMAGE=ghcr.io/worph/meta-core:latest
|
||||
FROM ${META_CORE_IMAGE} AS meta-core
|
||||
|
||||
# Stage 1: Runtime
|
||||
FROM python:3.11-slim
|
||||
|
||||
# Container registry metadata
|
||||
LABEL org.opencontainers.image.source=https://github.com/worph/meta-stremio
|
||||
LABEL org.opencontainers.image.description="MetaMesh Stremio addon with HLS transcoding"
|
||||
LABEL org.opencontainers.image.licenses=MIT
|
||||
|
||||
# Install FFmpeg, curl (for healthcheck), and other dependencies
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
ffmpeg \
|
||||
curl \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Set working directory
|
||||
WORKDIR /app
|
||||
|
||||
# Copy requirements and install Python dependencies
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Copy source files
|
||||
COPY src/ ./src/
|
||||
COPY www/ ./www/
|
||||
|
||||
# Copy meta-core sidecar binary
|
||||
COPY --from=meta-core /usr/local/bin/meta-core /usr/local/bin/meta-core
|
||||
RUN chmod +x /usr/local/bin/meta-core
|
||||
|
||||
# Copy startup script
|
||||
COPY docker/start.sh /app/start.sh
|
||||
RUN chmod +x /app/start.sh
|
||||
|
||||
# Create directories for cache (media comes from volume)
|
||||
RUN mkdir -p /data/cache
|
||||
|
||||
# Environment variables with defaults
|
||||
# Storage modes: 'leader' (discover via lock file), 'redis' (direct URL)
|
||||
ENV PORT=7000 \
|
||||
MEDIA_DIR=/files \
|
||||
CACHE_DIR=/data/cache \
|
||||
STORAGE_MODE=leader \
|
||||
META_CORE_PATH=/meta-core \
|
||||
FILES_PATH=/files \
|
||||
REDIS_URL=redis://localhost:6379 \
|
||||
REDIS_PREFIX= \
|
||||
SEGMENT_DURATION=4 \
|
||||
PREFETCH_SEGMENTS=4 \
|
||||
SCHEME=auto \
|
||||
SERVICE_NAME=meta-stremio \
|
||||
SERVICE_VERSION=1.0.0 \
|
||||
META_CORE_HTTP_PORT=9000 \
|
||||
LEADER_ELECTION_ENABLED=false
|
||||
|
||||
# Expose port
|
||||
EXPOSE 7000
|
||||
|
||||
# Health check
|
||||
HEALTHCHECK --interval=10s --timeout=5s --start-period=10s --retries=3 \
|
||||
CMD curl -f http://localhost:7000/health || exit 1
|
||||
|
||||
# Run the server via startup script (starts meta-core + Python server)
|
||||
CMD ["/app/start.sh"]
|
||||
@@ -0,0 +1,265 @@
|
||||
# Meta-Stremio
|
||||
|
||||
A standalone Stremio addon service for streaming personal media with on-the-fly HLS transcoding. Part of the MetaMesh decentralized media ecosystem.
|
||||
|
||||
## Overview
|
||||
|
||||
Meta-Stremio is a **process-read** service that:
|
||||
- Reads file metadata from the shared KV store (Redis)
|
||||
- Reads media files from the shared DATA volume
|
||||
- Provides HLS streaming with adaptive real-time FFmpeg transcoding
|
||||
- Serves as a Stremio addon for seamless playback
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────────┐
|
||||
│ MetaMesh Ecosystem │
|
||||
├─────────────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||||
│ │ meta-sort │ │ meta-stremio │ │ meta-fuse │ │
|
||||
│ │ [write meta] │ │ [read meta] │ │ [read meta] │ │
|
||||
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
|
||||
│ │ │ │ │
|
||||
│ ▼ ▼ ▼ │
|
||||
│ ┌─────────────────────────────────────────────────────┐ │
|
||||
│ │ Shared KV Store (Redis) │ │
|
||||
│ │ Leader election via flock on shared filesystem │ │
|
||||
│ │ DB stored in: DATA/Apps/meta-core/DB │ │
|
||||
│ └─────────────────────────────────────────────────────┘ │
|
||||
│ │ │
|
||||
│ ▼ │
|
||||
│ ┌─────────────────────────────────────────────────────┐ │
|
||||
│ │ Shared DATA Volume (media files) │ │
|
||||
│ │ meta-sort writes → meta-stremio/meta-fuse reads │ │
|
||||
│ └─────────────────────────────────────────────────────┘ │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
### High Performance
|
||||
- **Adaptive Quality** - Dynamic preset + CRF adjustment targeting 60-80% transcode ratio
|
||||
- **Intelligent Prefetch** - 4 segments ahead for smooth playback
|
||||
- **Single-threaded Encode** - 100% CPU per segment for fastest encoding
|
||||
- **Muxed Segments** - Video+audio in one FFmpeg call
|
||||
- **Segment Caching** - Persistent cache for repeated access
|
||||
|
||||
### Stremio Integration
|
||||
- **Catalog Endpoint** - Browse media library by type (movies, series)
|
||||
- **Meta Endpoint** - Detailed video information with codec details
|
||||
- **Stream Endpoint** - Multiple stream options per video
|
||||
- **Multi-Audio** - Separate HLS streams per audio track
|
||||
- **Subtitles** - Extract and serve embedded subtitles as VTT
|
||||
- **Language Configuration** - Configure display language (uses metadata stored by meta-sort's TMDB plugin)
|
||||
|
||||
### Storage Abstraction
|
||||
- **Leader Storage** - Auto-discovers meta-sort's Redis via leader election (recommended)
|
||||
- **Redis Storage** - Direct Redis connection via URL
|
||||
|
||||
## Project Structure
|
||||
|
||||
```
|
||||
meta-stremio/
|
||||
├── README.md
|
||||
├── CLAUDE.md # Development guide
|
||||
├── Dockerfile
|
||||
├── docker-compose.yml
|
||||
├── requirements.txt # Just redis
|
||||
├── src/
|
||||
│ ├── server.py # HTTP server + routing
|
||||
│ ├── stremio.py # Stremio handlers + storage integration
|
||||
│ ├── transcoder.py # HLS transcoding engine
|
||||
│ └── storage/
|
||||
│ ├── __init__.py
|
||||
│ ├── provider.py # Abstract StorageProvider
|
||||
│ ├── redis_storage.py # Direct Redis connection
|
||||
│ ├── leader_storage.py # Leader-aware Redis connection
|
||||
│ └── leader_discovery.py # Leader election discovery
|
||||
└── www/
|
||||
└── index.html # Dashboard
|
||||
```
|
||||
|
||||
## Installation
|
||||
|
||||
### Docker (Recommended)
|
||||
|
||||
```bash
|
||||
# Build
|
||||
docker build -t meta-stremio .
|
||||
|
||||
# Run with leader discovery (recommended - auto-discovers meta-sort's Redis)
|
||||
docker run -d \
|
||||
-p 7000:7000 \
|
||||
-v /path/to/media:/files:ro \
|
||||
-v /path/to/meta-core:/meta-core \
|
||||
meta-stremio
|
||||
|
||||
# Run with direct Redis connection
|
||||
docker run -d \
|
||||
-p 7000:7000 \
|
||||
-v /path/to/media:/files:ro \
|
||||
-e STORAGE_MODE=redis \
|
||||
-e REDIS_URL=redis://your-redis:6379 \
|
||||
meta-stremio
|
||||
```
|
||||
|
||||
### Docker Compose
|
||||
|
||||
```bash
|
||||
# Run as part of the MetaMesh stack (uses leader discovery)
|
||||
cd dev
|
||||
./start.sh
|
||||
```
|
||||
|
||||
### Standalone (Development)
|
||||
|
||||
```bash
|
||||
# Prerequisites: Python 3.9+, FFmpeg
|
||||
|
||||
# Install dependencies
|
||||
pip install -r requirements.txt
|
||||
|
||||
# Run
|
||||
cd src
|
||||
python server.py
|
||||
```
|
||||
|
||||
## Configuration
|
||||
|
||||
### Environment Variables
|
||||
|
||||
| Variable | Default | Description |
|
||||
|----------|---------|-------------|
|
||||
| `PORT` | `7000` | Server listen port |
|
||||
| `MEDIA_DIR` | `/data/media` | Media files directory |
|
||||
| `CACHE_DIR` | `/data/cache` | Transcoded segment cache |
|
||||
| `STORAGE_MODE` | `leader` | `leader` or `redis` |
|
||||
| `META_CORE_PATH` | `/meta-core` | Path to meta-core shared volume (for leader discovery) |
|
||||
| `FILES_PATH` | `/files` | Path to files volume |
|
||||
| `REDIS_URL` | `redis://localhost:6379` | Redis connection URL (for `redis` mode) |
|
||||
| `REDIS_PREFIX` | `meta-sort:` | Redis key prefix |
|
||||
| `SEGMENT_DURATION` | `4` | HLS segment length (seconds) |
|
||||
| `PREFETCH_SEGMENTS` | `4` | Segments to prefetch ahead |
|
||||
| `SCHEME` | `auto` | URL scheme (`http`, `https`, `auto`) |
|
||||
|
||||
## API Endpoints
|
||||
|
||||
### Dashboard
|
||||
| Endpoint | Method | Description |
|
||||
|----------|--------|-------------|
|
||||
| `/` | GET | Setup dashboard |
|
||||
| `/health` | GET | Health check with storage status |
|
||||
|
||||
### Dashboard API
|
||||
| Endpoint | Method | Description |
|
||||
|----------|--------|-------------|
|
||||
| `/api/stats` | GET | Library statistics |
|
||||
| `/api/storage-status` | GET | KV connection status |
|
||||
| `/api/library` | GET | Full library list |
|
||||
| `/api/library/refresh` | POST | Refresh library from KV |
|
||||
|
||||
### Stremio Protocol
|
||||
| Endpoint | Method | Description |
|
||||
|----------|--------|-------------|
|
||||
| `/manifest.json` | GET | Addon manifest |
|
||||
| `/catalog/:type/:id.json` | GET | Video catalog |
|
||||
| `/meta/:type/:id.json` | GET | Video metadata |
|
||||
| `/stream/:type/:id.json` | GET | Stream URLs |
|
||||
|
||||
### Transcoding
|
||||
| Endpoint | Method | Description |
|
||||
|----------|--------|-------------|
|
||||
| `/transcode/:path/master.m3u8` | GET | ABR master playlist |
|
||||
| `/transcode/:path/master_original_a0.m3u8` | GET | Original quality playlist |
|
||||
| `/transcode/:path/stream_a0_720p.m3u8` | GET | Quality stream playlist |
|
||||
| `/transcode/:path/seg_a0_720p_0.ts` | GET | Video segment |
|
||||
| `/transcode/:path/subtitle_0.vtt` | GET | Subtitle track |
|
||||
| `/direct/:path` | GET | Direct file serving |
|
||||
| `/transcode/metrics` | GET | Transcoding metrics |
|
||||
|
||||
## KV Store Schema
|
||||
|
||||
Meta-stremio reads from meta-sort's Redis using this key format:
|
||||
|
||||
```
|
||||
meta-sort:file:{hashId} → Hash containing all metadata
|
||||
- filePath → /media/movies/Movie.mkv
|
||||
- title → Movie Title
|
||||
- type → movie|series|anime
|
||||
- year → 2024
|
||||
- season → 1 (for series)
|
||||
- episode → 1 (for series)
|
||||
- duration → 7200 (seconds)
|
||||
- width → 1920
|
||||
- height → 1080
|
||||
- videoCodec → h264
|
||||
- audioCodec → aac
|
||||
- audioTracks → JSON string
|
||||
- subtitles → JSON string
|
||||
- imdbId → tt1234567
|
||||
- poster → URL
|
||||
```
|
||||
|
||||
## Stream Types
|
||||
|
||||
Each video provides multiple stream options:
|
||||
|
||||
1. **Direct File** - Original file, no transcoding
|
||||
- Best quality, may not play on all devices
|
||||
|
||||
2. **HLS Original** - Transcoded at source resolution
|
||||
- H.264/AAC in HLS container
|
||||
- One stream per audio track
|
||||
|
||||
3. **HLS ABR** - Adaptive bitrate with quality ladder
|
||||
- Multiple resolutions (1080p, 720p, 480p, 360p)
|
||||
- Automatic quality switching
|
||||
|
||||
## Transcoding Details
|
||||
|
||||
### Adaptive Quality System
|
||||
|
||||
The transcoder automatically adjusts encoding settings to maintain a 60-80% transcode ratio (segment encode time / segment duration):
|
||||
|
||||
- **Too Fast (<60%)**: Increase quality (lower CRF, slower preset)
|
||||
- **Too Slow (>80%)**: Decrease quality (higher CRF, faster preset)
|
||||
|
||||
### Quality Ladder
|
||||
|
||||
| Resolution | Video Bitrate | Audio Bitrate |
|
||||
|------------|---------------|---------------|
|
||||
| 1080p | 5000 kbps | 192 kbps |
|
||||
| 720p | 3000 kbps | 128 kbps |
|
||||
| 480p | 1500 kbps | 128 kbps |
|
||||
| 360p | 800 kbps | 96 kbps |
|
||||
|
||||
## Adding to Stremio
|
||||
|
||||
1. Open the dashboard at `http://localhost:7000`
|
||||
2. Click "Install in Stremio" or copy the manifest URL
|
||||
3. In Stremio: Settings → Addons → Enter URL → Install
|
||||
|
||||
## Development
|
||||
|
||||
```bash
|
||||
# Run in development mode (requires meta-sort running with Redis)
|
||||
cd src
|
||||
python server.py
|
||||
|
||||
# Or with direct Redis URL
|
||||
STORAGE_MODE=redis REDIS_URL=redis://localhost:6379 python server.py
|
||||
|
||||
# View logs
|
||||
tail -f /data/cache/*.log
|
||||
```
|
||||
|
||||
## Related Projects
|
||||
|
||||
- **[meta-sort](../meta-sort)** - File indexer (writes metadata to Redis)
|
||||
- **[meta-fuse](../meta-fuse)** - Virtual filesystem (reads metadata)
|
||||
- **[meta-orbit](../meta-orbit)** - P2P metadata sharing
|
||||
|
||||
## License
|
||||
|
||||
MIT
|
||||
@@ -0,0 +1,54 @@
|
||||
# Meta-Stremio Docker Compose
|
||||
# For local development and testing
|
||||
|
||||
version: '3.8'
|
||||
|
||||
services:
|
||||
meta-stremio:
|
||||
build: .
|
||||
container_name: meta-stremio
|
||||
ports:
|
||||
- "7000:7000"
|
||||
volumes:
|
||||
# Mount your media directory
|
||||
- ${MEDIA_DIR:-./media}:/data/media:ro
|
||||
# Cache for transcoded segments
|
||||
- meta-stremio-cache:/data/cache
|
||||
environment:
|
||||
- PORT=7000
|
||||
- MEDIA_DIR=/data/media
|
||||
- CACHE_DIR=/data/cache
|
||||
- STORAGE_MODE=${STORAGE_MODE:-leader}
|
||||
- REDIS_URL=${REDIS_URL:-redis://redis:6379}
|
||||
- REDIS_PREFIX=${REDIS_PREFIX:-meta-sort:}
|
||||
- SEGMENT_DURATION=${SEGMENT_DURATION:-4}
|
||||
- PREFETCH_SEGMENTS=${PREFETCH_SEGMENTS:-4}
|
||||
- SCHEME=${SCHEME:-auto}
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
redis:
|
||||
condition: service_healthy
|
||||
required: false
|
||||
|
||||
# Optional Redis for production use
|
||||
# Comment out if connecting to external Redis
|
||||
redis:
|
||||
image: redis:7-alpine
|
||||
container_name: meta-stremio-redis
|
||||
ports:
|
||||
- "6379:6379"
|
||||
volumes:
|
||||
- meta-stremio-redis:/data
|
||||
command: redis-server --appendonly yes
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 10s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
profiles:
|
||||
- with-redis
|
||||
|
||||
volumes:
|
||||
meta-stremio-cache:
|
||||
meta-stremio-redis:
|
||||
@@ -0,0 +1,43 @@
|
||||
#!/bin/bash
|
||||
# Meta-Stremio startup script
|
||||
# Starts meta-core sidecar before the Python server (when using leader discovery)
|
||||
|
||||
set -e
|
||||
|
||||
# Only start meta-core when using leader discovery mode
|
||||
if [ "${STORAGE_MODE}" = "leader" ]; then
|
||||
echo "[start.sh] Starting meta-core sidecar (leader discovery mode)..."
|
||||
|
||||
# Start meta-core in background
|
||||
/usr/local/bin/meta-core &
|
||||
META_CORE_PID=$!
|
||||
|
||||
# Wait for meta-core to be ready (health endpoint)
|
||||
echo "[start.sh] Waiting for meta-core to be ready..."
|
||||
for i in {1..30}; do
|
||||
if curl -sf http://localhost:9000/health > /dev/null 2>&1; then
|
||||
echo "[start.sh] meta-core is ready"
|
||||
break
|
||||
fi
|
||||
if [ $i -eq 30 ]; then
|
||||
echo "[start.sh] Warning: meta-core health check timeout, continuing anyway..."
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
else
|
||||
echo "[start.sh] Using direct Redis connection (STORAGE_MODE=${STORAGE_MODE}), skipping meta-core..."
|
||||
fi
|
||||
|
||||
# Start the Python server (foreground)
|
||||
echo "[start.sh] Starting meta-stremio server..."
|
||||
|
||||
# Use dev source if available (for development with hot reload)
|
||||
if [ -d "/app/src-dev" ] && [ -f "/app/src-dev/server.py" ]; then
|
||||
echo "[start.sh] Using development source (/app/src-dev)"
|
||||
cd /app/src-dev
|
||||
else
|
||||
echo "[start.sh] Using production source (/app/src)"
|
||||
cd /app/src
|
||||
fi
|
||||
|
||||
exec python server.py
|
||||
@@ -0,0 +1,10 @@
|
||||
# Meta-Stremio dependencies
|
||||
|
||||
# Redis client for KV storage
|
||||
redis>=5.0.0
|
||||
|
||||
# File watching for leader discovery (optional but recommended)
|
||||
watchdog>=4.0.0
|
||||
|
||||
# Image processing for poster resizing
|
||||
Pillow>=10.0.0
|
||||
@@ -0,0 +1,174 @@
|
||||
"""
|
||||
File Server API for Meta-Stremio
|
||||
|
||||
Serves files by CID by looking up the path from metadata.
|
||||
This is a generic file serving endpoint that can serve any file
|
||||
whose CID and path are stored in the metadata.
|
||||
|
||||
Endpoints:
|
||||
- GET /file/{cid} - Serve file by CID
|
||||
- GET /file/{cid}/w{width} - Serve image resized to width (images only)
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import io
|
||||
from typing import Optional, Tuple
|
||||
|
||||
# Optional PIL for image resizing
|
||||
try:
|
||||
from PIL import Image
|
||||
PIL_AVAILABLE = True
|
||||
except ImportError:
|
||||
PIL_AVAILABLE = False
|
||||
Image = None
|
||||
|
||||
# Configuration
|
||||
FILES_PATH = os.environ.get('FILES_PATH', '/files')
|
||||
|
||||
# Storage reference (set by init)
|
||||
_storage = None
|
||||
|
||||
|
||||
def init(storage) -> None:
|
||||
"""Initialize with storage reference."""
|
||||
global _storage
|
||||
_storage = storage
|
||||
|
||||
|
||||
def lookup_path_by_cid(cid: str) -> Optional[str]:
|
||||
"""
|
||||
Look up a file path by its CID from Redis.
|
||||
|
||||
Files (including poster images) are stored in Redis as file:{cid} entries.
|
||||
The file path is stored in the 'path' field.
|
||||
|
||||
Returns the relative path if found, None otherwise.
|
||||
"""
|
||||
if not _storage:
|
||||
return None
|
||||
|
||||
try:
|
||||
# Look up directly by CID - poster files are processed like any other file
|
||||
file_path = _storage.get_file_path_by_cid(cid)
|
||||
if file_path:
|
||||
return file_path
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f"[FileServer] Error looking up CID {cid}: {e}")
|
||||
return None
|
||||
|
||||
|
||||
def get_file_path(cid: str) -> Optional[str]:
|
||||
"""Get the absolute file path for a CID."""
|
||||
rel_path = lookup_path_by_cid(cid)
|
||||
if rel_path:
|
||||
return os.path.join(FILES_PATH, rel_path)
|
||||
return None
|
||||
|
||||
|
||||
def resize_image(image_data: bytes, width: int) -> bytes:
|
||||
"""Resize an image to the specified width, maintaining aspect ratio."""
|
||||
if not PIL_AVAILABLE:
|
||||
raise RuntimeError("PIL not available for image resizing")
|
||||
|
||||
img = Image.open(io.BytesIO(image_data))
|
||||
|
||||
# Calculate new height maintaining aspect ratio
|
||||
ratio = width / img.width
|
||||
height = int(img.height * ratio)
|
||||
|
||||
# Use high-quality resampling
|
||||
resized = img.resize((width, height), Image.Resampling.LANCZOS)
|
||||
|
||||
# Save to bytes
|
||||
output = io.BytesIO()
|
||||
# Preserve format, default to JPEG
|
||||
fmt = img.format or 'JPEG'
|
||||
if fmt.upper() == 'PNG' and img.mode == 'RGBA':
|
||||
resized.save(output, format='PNG', optimize=True)
|
||||
else:
|
||||
# Convert to RGB for JPEG
|
||||
if resized.mode in ('RGBA', 'P'):
|
||||
resized = resized.convert('RGB')
|
||||
resized.save(output, format='JPEG', quality=85, optimize=True)
|
||||
|
||||
return output.getvalue()
|
||||
|
||||
|
||||
def serve_file(cid: str, width: Optional[int] = None) -> Tuple[Optional[bytes], str, int]:
|
||||
"""
|
||||
Serve a file by CID.
|
||||
|
||||
Args:
|
||||
cid: The CID of the file
|
||||
width: Optional width for resizing (images only)
|
||||
|
||||
Returns:
|
||||
Tuple of (file_data, content_type, status_code)
|
||||
"""
|
||||
# Get file path from CID
|
||||
file_path = get_file_path(cid)
|
||||
|
||||
if not file_path:
|
||||
return None, 'text/plain', 404
|
||||
|
||||
if not os.path.exists(file_path):
|
||||
print(f"[FileServer] File not found: {file_path}")
|
||||
return None, 'text/plain', 404
|
||||
|
||||
# Determine content type from extension
|
||||
ext = os.path.splitext(file_path)[1].lower()
|
||||
content_types = {
|
||||
'.jpg': 'image/jpeg',
|
||||
'.jpeg': 'image/jpeg',
|
||||
'.png': 'image/png',
|
||||
'.webp': 'image/webp',
|
||||
'.gif': 'image/gif',
|
||||
'.mp4': 'video/mp4',
|
||||
'.mkv': 'video/x-matroska',
|
||||
'.avi': 'video/x-msvideo',
|
||||
'.webm': 'video/webm',
|
||||
}
|
||||
content_type = content_types.get(ext, 'application/octet-stream')
|
||||
|
||||
try:
|
||||
with open(file_path, 'rb') as f:
|
||||
file_data = f.read()
|
||||
|
||||
# Resize if width is specified and it's an image
|
||||
if width and PIL_AVAILABLE and content_type.startswith('image/'):
|
||||
try:
|
||||
file_data = resize_image(file_data, width)
|
||||
# After resize, it's always JPEG (unless PNG with alpha)
|
||||
if ext != '.png':
|
||||
content_type = 'image/jpeg'
|
||||
except Exception as e:
|
||||
print(f"[FileServer] Resize error: {e}")
|
||||
# Fall through to serve original
|
||||
|
||||
return file_data, content_type, 200
|
||||
|
||||
except Exception as e:
|
||||
print(f"[FileServer] Error reading {file_path}: {e}")
|
||||
return None, 'text/plain', 500
|
||||
|
||||
|
||||
def get_file_url(cid: str, base_url: str, width: Optional[int] = None) -> str:
|
||||
"""
|
||||
Generate a file URL for a CID.
|
||||
|
||||
Args:
|
||||
cid: The CID of the file
|
||||
base_url: Base URL of the server
|
||||
width: Optional width for resizing (images only)
|
||||
|
||||
Returns:
|
||||
Full URL to the file
|
||||
"""
|
||||
if not cid:
|
||||
return ""
|
||||
|
||||
if width:
|
||||
return f"{base_url}/file/{cid}/w{width}"
|
||||
return f"{base_url}/file/{cid}"
|
||||
@@ -0,0 +1,265 @@
|
||||
"""
|
||||
Plugin Completion Subscriber for meta-stremio.
|
||||
|
||||
Subscribes to Redis pub/sub channel 'meta-sort:plugin:complete' to be notified
|
||||
when specific plugins finish processing files. This allows Stremio to:
|
||||
1. Log metadata updates for debugging
|
||||
2. Invalidate any local caches (if implemented)
|
||||
3. Track which files have complete metadata
|
||||
|
||||
Plugins of interest to Stremio:
|
||||
- filename-parser: Provides season/episode info for TV vs Movie categorization
|
||||
- tmdb: Provides rich metadata (title, year, poster, description, etc.)
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import json
|
||||
import threading
|
||||
from typing import Callable, Optional, List, Set
|
||||
|
||||
try:
|
||||
import redis
|
||||
REDIS_AVAILABLE = True
|
||||
except ImportError:
|
||||
REDIS_AVAILABLE = False
|
||||
redis = None
|
||||
|
||||
|
||||
# Redis configuration
|
||||
REDIS_URL = os.environ.get('REDIS_URL', 'redis://localhost:6379')
|
||||
|
||||
# Plugins that Stremio cares about
|
||||
WATCHED_PLUGINS: Set[str] = {'filename-parser', 'tmdb'}
|
||||
|
||||
# Channel for plugin completion events
|
||||
PLUGIN_COMPLETE_CHANNEL = 'meta-sort:plugin:complete'
|
||||
|
||||
|
||||
class PluginSubscriber:
|
||||
"""
|
||||
Subscribes to plugin completion events from meta-sort.
|
||||
|
||||
When filename-parser or tmdb plugins complete, the subscriber
|
||||
receives notifications that can be used to update Stremio's view
|
||||
of the metadata.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
url: str = None,
|
||||
watched_plugins: Set[str] = None,
|
||||
on_plugin_complete: Callable[[str, str, str], None] = None
|
||||
):
|
||||
"""
|
||||
Initialize the plugin subscriber.
|
||||
|
||||
Args:
|
||||
url: Redis connection URL
|
||||
watched_plugins: Set of plugin IDs to watch (default: filename-parser, tmdb)
|
||||
on_plugin_complete: Callback when a watched plugin completes
|
||||
Signature: (file_hash, plugin_id, file_path) -> None
|
||||
"""
|
||||
if not REDIS_AVAILABLE:
|
||||
raise ImportError("redis package not installed. Run: pip install redis")
|
||||
|
||||
self._url = url or REDIS_URL
|
||||
self._watched_plugins = watched_plugins or WATCHED_PLUGINS
|
||||
self._on_plugin_complete = on_plugin_complete
|
||||
self._pubsub: Optional[redis.client.PubSub] = None
|
||||
self._thread: Optional[threading.Thread] = None
|
||||
self._running = False
|
||||
self._client: Optional[redis.Redis] = None
|
||||
|
||||
# Track files with complete metadata (all watched plugins finished)
|
||||
self._file_plugin_status: dict[str, Set[str]] = {}
|
||||
|
||||
def start(self) -> bool:
|
||||
"""Start the subscriber in a background thread."""
|
||||
if self._running:
|
||||
return True
|
||||
|
||||
try:
|
||||
self._client = redis.from_url(self._url, decode_responses=True)
|
||||
self._client.ping() # Test connection
|
||||
|
||||
self._pubsub = self._client.pubsub()
|
||||
self._pubsub.subscribe(PLUGIN_COMPLETE_CHANNEL)
|
||||
|
||||
self._running = True
|
||||
self._thread = threading.Thread(
|
||||
target=self._listen_loop,
|
||||
daemon=True,
|
||||
name='PluginSubscriber'
|
||||
)
|
||||
self._thread.start()
|
||||
|
||||
print(f"[PluginSubscriber] Started, watching plugins: {', '.join(self._watched_plugins)}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"[PluginSubscriber] Failed to start: {e}")
|
||||
self._running = False
|
||||
return False
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop the subscriber."""
|
||||
self._running = False
|
||||
|
||||
if self._pubsub:
|
||||
try:
|
||||
self._pubsub.unsubscribe()
|
||||
self._pubsub.close()
|
||||
except Exception:
|
||||
pass
|
||||
self._pubsub = None
|
||||
|
||||
if self._client:
|
||||
try:
|
||||
self._client.close()
|
||||
except Exception:
|
||||
pass
|
||||
self._client = None
|
||||
|
||||
print("[PluginSubscriber] Stopped")
|
||||
|
||||
def _listen_loop(self) -> None:
|
||||
"""Background loop that listens for plugin completion events."""
|
||||
while self._running and self._pubsub:
|
||||
try:
|
||||
message = self._pubsub.get_message(timeout=1.0)
|
||||
if message and message['type'] == 'message':
|
||||
self._handle_message(message['data'])
|
||||
except redis.ConnectionError:
|
||||
print("[PluginSubscriber] Connection lost, attempting reconnect...")
|
||||
self._reconnect()
|
||||
except Exception as e:
|
||||
if self._running:
|
||||
print(f"[PluginSubscriber] Error in listen loop: {e}")
|
||||
|
||||
def _reconnect(self) -> None:
|
||||
"""Attempt to reconnect to Redis."""
|
||||
import time
|
||||
|
||||
for attempt in range(5):
|
||||
if not self._running:
|
||||
return
|
||||
|
||||
try:
|
||||
time.sleep(2 ** attempt) # Exponential backoff
|
||||
|
||||
if self._pubsub:
|
||||
self._pubsub.close()
|
||||
if self._client:
|
||||
self._client.close()
|
||||
|
||||
self._client = redis.from_url(self._url, decode_responses=True)
|
||||
self._client.ping()
|
||||
|
||||
self._pubsub = self._client.pubsub()
|
||||
self._pubsub.subscribe(PLUGIN_COMPLETE_CHANNEL)
|
||||
|
||||
print("[PluginSubscriber] Reconnected successfully")
|
||||
return
|
||||
|
||||
except Exception as e:
|
||||
print(f"[PluginSubscriber] Reconnect attempt {attempt + 1} failed: {e}")
|
||||
|
||||
print("[PluginSubscriber] Failed to reconnect after 5 attempts")
|
||||
self._running = False
|
||||
|
||||
def _handle_message(self, data: str) -> None:
|
||||
"""Handle a plugin completion message."""
|
||||
try:
|
||||
payload = json.loads(data)
|
||||
file_hash = payload.get('fileHash', '')
|
||||
plugin_id = payload.get('pluginId', '')
|
||||
file_path = payload.get('filePath', '')
|
||||
|
||||
# Only process plugins we're watching
|
||||
if plugin_id not in self._watched_plugins:
|
||||
return
|
||||
|
||||
# Track plugin completion for this file
|
||||
if file_hash not in self._file_plugin_status:
|
||||
self._file_plugin_status[file_hash] = set()
|
||||
self._file_plugin_status[file_hash].add(plugin_id)
|
||||
|
||||
# Log the completion
|
||||
print(f"[PluginSubscriber] Plugin '{plugin_id}' completed for {file_hash[:12]}...")
|
||||
|
||||
# Check if all watched plugins have completed for this file
|
||||
completed_plugins = self._file_plugin_status[file_hash]
|
||||
if self._watched_plugins.issubset(completed_plugins):
|
||||
print(f"[PluginSubscriber] All watched plugins complete for {file_hash[:12]}...")
|
||||
# Could trigger a cache refresh here if we had local caching
|
||||
|
||||
# Call the callback if provided
|
||||
if self._on_plugin_complete:
|
||||
try:
|
||||
self._on_plugin_complete(file_hash, plugin_id, file_path)
|
||||
except Exception as e:
|
||||
print(f"[PluginSubscriber] Callback error: {e}")
|
||||
|
||||
except json.JSONDecodeError:
|
||||
print(f"[PluginSubscriber] Invalid JSON message: {data[:100]}")
|
||||
except Exception as e:
|
||||
print(f"[PluginSubscriber] Error handling message: {e}")
|
||||
|
||||
def is_running(self) -> bool:
|
||||
"""Check if the subscriber is running."""
|
||||
return self._running
|
||||
|
||||
def get_status(self) -> dict:
|
||||
"""Get subscriber status for debugging."""
|
||||
return {
|
||||
'running': self._running,
|
||||
'watched_plugins': list(self._watched_plugins),
|
||||
'tracked_files': len(self._file_plugin_status),
|
||||
}
|
||||
|
||||
|
||||
# Global subscriber instance
|
||||
_subscriber: Optional[PluginSubscriber] = None
|
||||
|
||||
|
||||
def init_subscriber(
|
||||
on_plugin_complete: Callable[[str, str, str], None] = None
|
||||
) -> Optional[PluginSubscriber]:
|
||||
"""
|
||||
Initialize and start the global plugin subscriber.
|
||||
|
||||
Args:
|
||||
on_plugin_complete: Optional callback when watched plugins complete
|
||||
|
||||
Returns:
|
||||
The subscriber instance, or None if Redis is unavailable
|
||||
"""
|
||||
global _subscriber
|
||||
|
||||
if not REDIS_AVAILABLE:
|
||||
print("[PluginSubscriber] Redis not available, skipping subscriber init")
|
||||
return None
|
||||
|
||||
if _subscriber and _subscriber.is_running():
|
||||
return _subscriber
|
||||
|
||||
_subscriber = PluginSubscriber(on_plugin_complete=on_plugin_complete)
|
||||
if _subscriber.start():
|
||||
return _subscriber
|
||||
|
||||
_subscriber = None
|
||||
return None
|
||||
|
||||
|
||||
def get_subscriber() -> Optional[PluginSubscriber]:
|
||||
"""Get the global subscriber instance."""
|
||||
return _subscriber
|
||||
|
||||
|
||||
def stop_subscriber() -> None:
|
||||
"""Stop the global subscriber."""
|
||||
global _subscriber
|
||||
if _subscriber:
|
||||
_subscriber.stop()
|
||||
_subscriber = None
|
||||
+178
@@ -0,0 +1,178 @@
|
||||
"""
|
||||
Poster API for Meta-Stremio
|
||||
|
||||
Serves poster and backdrop images by CID with optional resizing.
|
||||
Builds a CID -> file path index from video metadata.
|
||||
|
||||
Endpoints:
|
||||
- GET /poster/{cid} - Serve original image
|
||||
- GET /poster/{cid}/w{width} - Serve resized image (width specified)
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import io
|
||||
from typing import Optional, Dict, Tuple
|
||||
from threading import Lock
|
||||
|
||||
# Optional PIL for image resizing
|
||||
try:
|
||||
from PIL import Image
|
||||
PIL_AVAILABLE = True
|
||||
except ImportError:
|
||||
PIL_AVAILABLE = False
|
||||
Image = None
|
||||
|
||||
# Configuration
|
||||
FILES_PATH = os.environ.get('FILES_PATH', '/files')
|
||||
|
||||
# CID -> file path index
|
||||
_cid_index: Dict[str, str] = {}
|
||||
_index_lock = Lock()
|
||||
_index_built = False
|
||||
|
||||
|
||||
def build_cid_index(storage) -> None:
|
||||
"""Build CID to file path index from storage metadata."""
|
||||
global _cid_index, _index_built
|
||||
|
||||
with _index_lock:
|
||||
_cid_index.clear()
|
||||
|
||||
try:
|
||||
videos = storage.get_all_videos()
|
||||
for video in videos:
|
||||
# Index poster
|
||||
if video.poster and video.poster_path:
|
||||
_cid_index[video.poster] = video.poster_path
|
||||
# Index backdrop
|
||||
if video.backdrop and video.backdrop_path:
|
||||
_cid_index[video.backdrop] = video.backdrop_path
|
||||
|
||||
_index_built = True
|
||||
print(f"[Poster] Built CID index: {len(_cid_index)} images")
|
||||
except Exception as e:
|
||||
print(f"[Poster] Error building CID index: {e}")
|
||||
|
||||
|
||||
def get_image_path(cid: str) -> Optional[str]:
|
||||
"""Get the file path for a CID."""
|
||||
with _index_lock:
|
||||
rel_path = _cid_index.get(cid)
|
||||
if rel_path:
|
||||
return os.path.join(FILES_PATH, rel_path)
|
||||
return None
|
||||
|
||||
|
||||
def is_index_built() -> bool:
|
||||
"""Check if the CID index has been built."""
|
||||
return _index_built
|
||||
|
||||
|
||||
def get_index_size() -> int:
|
||||
"""Get the number of images in the index."""
|
||||
with _index_lock:
|
||||
return len(_cid_index)
|
||||
|
||||
|
||||
def resize_image(image_data: bytes, width: int) -> bytes:
|
||||
"""Resize an image to the specified width, maintaining aspect ratio."""
|
||||
if not PIL_AVAILABLE:
|
||||
raise RuntimeError("PIL not available for image resizing")
|
||||
|
||||
img = Image.open(io.BytesIO(image_data))
|
||||
|
||||
# Calculate new height maintaining aspect ratio
|
||||
ratio = width / img.width
|
||||
height = int(img.height * ratio)
|
||||
|
||||
# Use high-quality resampling
|
||||
resized = img.resize((width, height), Image.Resampling.LANCZOS)
|
||||
|
||||
# Save to bytes
|
||||
output = io.BytesIO()
|
||||
# Preserve format, default to JPEG
|
||||
fmt = img.format or 'JPEG'
|
||||
if fmt.upper() == 'PNG' and img.mode == 'RGBA':
|
||||
resized.save(output, format='PNG', optimize=True)
|
||||
else:
|
||||
# Convert to RGB for JPEG
|
||||
if resized.mode in ('RGBA', 'P'):
|
||||
resized = resized.convert('RGB')
|
||||
resized.save(output, format='JPEG', quality=85, optimize=True)
|
||||
|
||||
return output.getvalue()
|
||||
|
||||
|
||||
def serve_poster(cid: str, width: Optional[int] = None) -> Tuple[Optional[bytes], str, int]:
|
||||
"""
|
||||
Serve a poster image by CID.
|
||||
|
||||
Args:
|
||||
cid: The CID of the image
|
||||
width: Optional width for resizing
|
||||
|
||||
Returns:
|
||||
Tuple of (image_data, content_type, status_code)
|
||||
"""
|
||||
# Get file path from CID
|
||||
file_path = get_image_path(cid)
|
||||
|
||||
if not file_path:
|
||||
return None, 'text/plain', 404
|
||||
|
||||
if not os.path.exists(file_path):
|
||||
print(f"[Poster] File not found: {file_path}")
|
||||
return None, 'text/plain', 404
|
||||
|
||||
# Determine content type from extension
|
||||
ext = os.path.splitext(file_path)[1].lower()
|
||||
content_types = {
|
||||
'.jpg': 'image/jpeg',
|
||||
'.jpeg': 'image/jpeg',
|
||||
'.png': 'image/png',
|
||||
'.webp': 'image/webp',
|
||||
'.gif': 'image/gif',
|
||||
}
|
||||
content_type = content_types.get(ext, 'image/jpeg')
|
||||
|
||||
try:
|
||||
with open(file_path, 'rb') as f:
|
||||
image_data = f.read()
|
||||
|
||||
# Resize if width is specified
|
||||
if width and PIL_AVAILABLE:
|
||||
try:
|
||||
image_data = resize_image(image_data, width)
|
||||
# After resize, it's always JPEG (unless PNG with alpha)
|
||||
if not (ext == '.png'):
|
||||
content_type = 'image/jpeg'
|
||||
except Exception as e:
|
||||
print(f"[Poster] Resize error: {e}")
|
||||
# Fall through to serve original
|
||||
|
||||
return image_data, content_type, 200
|
||||
|
||||
except Exception as e:
|
||||
print(f"[Poster] Error reading {file_path}: {e}")
|
||||
return None, 'text/plain', 500
|
||||
|
||||
|
||||
def get_poster_url(cid: str, base_url: str, width: Optional[int] = None) -> str:
|
||||
"""
|
||||
Generate a poster URL for a CID.
|
||||
|
||||
Args:
|
||||
cid: The CID of the image
|
||||
base_url: Base URL of the server
|
||||
width: Optional width for resizing
|
||||
|
||||
Returns:
|
||||
Full URL to the poster image
|
||||
"""
|
||||
if not cid:
|
||||
return ""
|
||||
|
||||
if width:
|
||||
return f"{base_url}/poster/{cid}/w{width}"
|
||||
return f"{base_url}/poster/{cid}"
|
||||
+955
@@ -0,0 +1,955 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Meta-Stremio Server
|
||||
|
||||
A standalone Stremio addon that:
|
||||
1. Reads video metadata from KV storage (written by meta-sort)
|
||||
2. Transcodes video on-the-fly using FFmpeg with adaptive quality
|
||||
3. Serves HLS streams with muxed video+audio segments
|
||||
4. Provides a dashboard for monitoring and setup
|
||||
5. Registers with service discovery for inter-service navigation
|
||||
|
||||
Environment Variables:
|
||||
- MEDIA_DIR: Directory containing video files (default: /data/media)
|
||||
- CACHE_DIR: Directory for transcoded segments (default: /data/cache)
|
||||
- PORT: HTTP server port (default: 7000)
|
||||
- STORAGE_MODE: Storage backend 'leader' or 'redis' (default: leader)
|
||||
- META_CORE_PATH: Path to meta-core shared volume (default: /meta-core)
|
||||
- FILES_PATH: Path to files shared volume (default: /files)
|
||||
- REDIS_URL: Redis connection URL (default: redis://localhost:6379)
|
||||
- REDIS_PREFIX: Redis key prefix (default: meta-sort:)
|
||||
- SCHEME: URL scheme for generated URLs (http/https/auto)
|
||||
- SEGMENT_DURATION: HLS segment length in seconds (default: 4)
|
||||
- PREFETCH_SEGMENTS: How many segments to prefetch ahead (default: 4)
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
import json
|
||||
import signal
|
||||
import sys
|
||||
import base64
|
||||
from http.server import HTTPServer, BaseHTTPRequestHandler
|
||||
from urllib.parse import urlparse, unquote
|
||||
import threading
|
||||
|
||||
import stremio
|
||||
import transcoder
|
||||
from storage import init_service_discovery, get_service_discovery
|
||||
import fileserver
|
||||
import plugin_subscriber
|
||||
|
||||
# Configuration
|
||||
PORT = int(os.environ.get('PORT', '7000'))
|
||||
SCHEME = os.environ.get('SCHEME', '').lower().strip()
|
||||
META_CORE_PATH = os.environ.get('META_CORE_PATH', '/meta-core')
|
||||
BASE_URL = os.environ.get('BASE_URL', '')
|
||||
|
||||
# Initialize storage
|
||||
storage = stremio.init_storage()
|
||||
|
||||
# Initialize service discovery (only if META_CORE_PATH exists)
|
||||
service_discovery = None
|
||||
if os.path.exists(META_CORE_PATH):
|
||||
try:
|
||||
service_discovery = init_service_discovery(base_url=BASE_URL if BASE_URL else None)
|
||||
except Exception as e:
|
||||
print(f"[Server] Service discovery init failed: {e}")
|
||||
|
||||
# Global Stremio handler
|
||||
stremio_handler = stremio.StremioHandler()
|
||||
|
||||
|
||||
def parse_config_from_path(path: str) -> tuple[str, dict]:
|
||||
"""
|
||||
Parse Stremio config from URL path.
|
||||
|
||||
Stremio passes config as URL-safe base64-encoded JSON in the path:
|
||||
/{config}/manifest.json -> config dict
|
||||
/manifest.json -> empty dict
|
||||
|
||||
Returns:
|
||||
(remaining_path, config_dict)
|
||||
"""
|
||||
# Check if path starts with a potential config segment
|
||||
# Config paths look like: /eyJsYW5n.../manifest.json
|
||||
parts = path.strip('/').split('/', 1)
|
||||
|
||||
if len(parts) >= 1 and parts[0]:
|
||||
potential_config = parts[0]
|
||||
|
||||
# Skip known non-config paths
|
||||
if potential_config in ('manifest.json', 'catalog', 'meta', 'stream', 'stremio',
|
||||
'health', 'api', 'transcode', 'direct', 'poster', 'configure'):
|
||||
return path, {}
|
||||
|
||||
# Try to decode as base64 config
|
||||
try:
|
||||
# Add padding if needed
|
||||
padded = potential_config + '=' * (4 - len(potential_config) % 4)
|
||||
decoded = base64.urlsafe_b64decode(padded).decode('utf-8')
|
||||
config = json.loads(decoded)
|
||||
|
||||
# Return remaining path with leading slash
|
||||
remaining = '/' + parts[1] if len(parts) > 1 else '/'
|
||||
return remaining, config
|
||||
except (ValueError, json.JSONDecodeError, UnicodeDecodeError):
|
||||
# Not a valid config, return original path
|
||||
pass
|
||||
|
||||
return path, {}
|
||||
|
||||
|
||||
def encode_config(config: dict) -> str:
|
||||
"""Encode config dict to URL-safe base64 string."""
|
||||
json_str = json.dumps(config, separators=(',', ':'))
|
||||
encoded = base64.urlsafe_b64encode(json_str.encode('utf-8')).decode('utf-8')
|
||||
return encoded.rstrip('=')
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
def log_message(self, fmt, *args):
|
||||
print(f"[{self.address_string()}] {fmt % args}")
|
||||
|
||||
def send_json(self, data: dict, status: int = 200):
|
||||
body = json.dumps(data).encode()
|
||||
self.send_response(status)
|
||||
self.send_header('Content-Type', 'application/json')
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
def send_data(self, data: bytes, content_type: str):
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Type', content_type)
|
||||
self.send_header('Content-Length', len(data))
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
self.end_headers()
|
||||
self.wfile.write(data)
|
||||
|
||||
def do_OPTIONS(self):
|
||||
self.send_response(200)
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
self.send_header('Access-Control-Allow-Methods', 'GET, HEAD, POST, OPTIONS')
|
||||
self.send_header('Access-Control-Allow-Headers', 'Content-Type, Range')
|
||||
self.end_headers()
|
||||
|
||||
def do_HEAD(self):
|
||||
parsed = urlparse(self.path)
|
||||
path = unquote(parsed.path)
|
||||
|
||||
if path.startswith('/stremio/') or path == '/' or path.startswith('/manifest.json'):
|
||||
self.send_response(200)
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
if path.endswith('.json'):
|
||||
self.send_header('Content-Type', 'application/json')
|
||||
else:
|
||||
self.send_header('Content-Type', 'text/html')
|
||||
self.end_headers()
|
||||
elif path.startswith('/transcode/') or path.startswith('/direct/'):
|
||||
self.send_response(200)
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
if path.endswith('.m3u8'):
|
||||
self.send_header('Content-Type', 'application/vnd.apple.mpegurl')
|
||||
elif path.endswith('.ts'):
|
||||
self.send_header('Content-Type', 'video/mp2t')
|
||||
elif path.endswith('.vtt'):
|
||||
self.send_header('Content-Type', 'text/vtt')
|
||||
else:
|
||||
self.send_header('Content-Type', 'application/octet-stream')
|
||||
self.end_headers()
|
||||
elif path.startswith('/file/') or path.startswith('/poster/'):
|
||||
# Generic file serving by CID - /file/{cid} or /poster/{cid} (backward compat)
|
||||
m = re.match(r'^/(?:file|poster)/([a-zA-Z0-9]+)(?:/w(\d+))?$', path)
|
||||
if m:
|
||||
cid = m.group(1)
|
||||
# Check if file exists by looking up CID in metadata
|
||||
file_path = fileserver.get_file_path(cid)
|
||||
if file_path and os.path.exists(file_path):
|
||||
self.send_response(200)
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
self.send_header('Content-Type', 'image/jpeg')
|
||||
self.send_header('Cache-Control', 'public, max-age=604800')
|
||||
self.end_headers()
|
||||
else:
|
||||
self.send_error(404, f"File not found: {cid}")
|
||||
else:
|
||||
self.send_error(404, "Invalid file path")
|
||||
else:
|
||||
self.send_error(404)
|
||||
|
||||
def do_POST(self):
|
||||
parsed = urlparse(self.path)
|
||||
path = unquote(parsed.path)
|
||||
|
||||
# Library refresh endpoint
|
||||
if path == '/api/library/refresh':
|
||||
try:
|
||||
# Reconnect storage to refresh
|
||||
storage = stremio.get_storage()
|
||||
if hasattr(storage, 'disconnect'):
|
||||
storage.disconnect()
|
||||
stremio.init_storage()
|
||||
# Reinitialize fileserver with new storage
|
||||
fileserver.init(stremio.get_storage())
|
||||
return self.send_json({'status': 'ok', 'message': 'Library refreshed'})
|
||||
except Exception as e:
|
||||
return self.send_json({'status': 'error', 'message': str(e)}, 500)
|
||||
|
||||
# Reset metrics
|
||||
if path == '/transcode/reset-metrics':
|
||||
transcoder.reset_metrics()
|
||||
return self.send_json({'status': 'ok'})
|
||||
|
||||
self.send_error(404)
|
||||
|
||||
def do_GET(self):
|
||||
parsed = urlparse(self.path)
|
||||
raw_path = unquote(parsed.path)
|
||||
|
||||
# Parse config from path (e.g., /eyJsYW5n.../manifest.json)
|
||||
path, config = parse_config_from_path(raw_path)
|
||||
|
||||
# Root - serve setup page
|
||||
if path == '/' or path == '/index.html':
|
||||
return self.serve_setup_page()
|
||||
|
||||
# Configure page
|
||||
if path == '/configure':
|
||||
return self.serve_configure_page()
|
||||
|
||||
# API: Get supported languages
|
||||
if path == '/api/languages':
|
||||
return self.send_json({
|
||||
'languages': [{'code': code, 'name': name} for code, name in stremio.get_supported_languages()],
|
||||
})
|
||||
|
||||
# Health check
|
||||
if path == '/health':
|
||||
storage = stremio.get_storage()
|
||||
return self.send_json({
|
||||
'status': 'ok',
|
||||
'storage': storage.get_status() if storage else {'connected': False},
|
||||
})
|
||||
|
||||
# === Dashboard API ===
|
||||
|
||||
# Storage status
|
||||
if path == '/api/storage-status':
|
||||
storage = stremio.get_storage()
|
||||
return self.send_json(storage.get_status() if storage else {'connected': False})
|
||||
|
||||
# Library stats
|
||||
if path == '/api/stats':
|
||||
stats = stremio.get_library_stats()
|
||||
return self.send_json(stats)
|
||||
|
||||
# Library list
|
||||
if path == '/api/library':
|
||||
storage = stremio.get_storage()
|
||||
videos = storage.get_all_videos() if storage else []
|
||||
return self.send_json({
|
||||
'videos': [v.to_dict() for v in videos],
|
||||
'count': len(videos),
|
||||
})
|
||||
|
||||
# Discovered services (for inter-service navigation)
|
||||
if path == '/api/services':
|
||||
return self.handle_services_api()
|
||||
|
||||
# Plugin subscriber status
|
||||
if path == '/api/plugin-subscriber':
|
||||
subscriber = plugin_subscriber.get_subscriber()
|
||||
if subscriber:
|
||||
return self.send_json(subscriber.get_status())
|
||||
return self.send_json({'running': False, 'reason': 'Not initialized'})
|
||||
|
||||
# === File API ===
|
||||
# /file/{cid} or /poster/{cid} (backward compat) - serve file by CID
|
||||
# /file/{cid}/w{width} - serve resized image
|
||||
m = re.match(r'^/(?:file|poster)/([a-zA-Z0-9]+)(?:/w(\d+))?$', path)
|
||||
if m:
|
||||
return self.handle_file(m.group(1), int(m.group(2)) if m.group(2) else None)
|
||||
|
||||
# === Stremio manifest ===
|
||||
if path == '/manifest.json' or path == '/stremio/manifest.json':
|
||||
return self.handle_stremio_manifest(config)
|
||||
|
||||
# Stremio catalog
|
||||
m = re.match(r'^(?:/stremio)?/catalog/(\w+)/([^/]+)(?:/([^.]+))?\.json$', path)
|
||||
if m:
|
||||
return self.handle_stremio_catalog(m.group(1), m.group(2), m.group(3), config)
|
||||
|
||||
# Stremio meta
|
||||
m = re.match(r'^(?:/stremio)?/meta/(\w+)/([^/]+)\.json$', path)
|
||||
if m:
|
||||
return self.handle_stremio_meta(m.group(1), m.group(2), config)
|
||||
|
||||
# Stremio stream
|
||||
m = re.match(r'^(?:/stremio)?/stream/(\w+)/([^/]+)\.json$', path)
|
||||
if m:
|
||||
return self.handle_stremio_stream(m.group(1), m.group(2), config)
|
||||
|
||||
# === Transcoder endpoints ===
|
||||
|
||||
# Metrics
|
||||
if path == '/transcode/metrics':
|
||||
metrics = transcoder.get_metrics()
|
||||
metrics['total_files'] = stremio.get_storage().get_video_count()
|
||||
return self.send_json(metrics)
|
||||
|
||||
# Direct file serving
|
||||
m = re.match(r'^/direct/(.+)$', path)
|
||||
if m:
|
||||
return self.handle_direct_file(m.group(1))
|
||||
|
||||
# Master playlist variants
|
||||
m = re.match(r'^/transcode/(.+?)/master_(\w+)_a(\d+)\.m3u8$', path)
|
||||
if m:
|
||||
return self.handle_master_playlist(m.group(1), m.group(2), int(m.group(3)))
|
||||
|
||||
m = re.match(r'^/transcode/(.+?)/master_a(\d+)\.m3u8$', path)
|
||||
if m:
|
||||
return self.handle_master_playlist(m.group(1), None, int(m.group(2)))
|
||||
|
||||
m = re.match(r'^/transcode/(.+?)/master\.m3u8$', path)
|
||||
if m:
|
||||
return self.handle_master_playlist(m.group(1))
|
||||
|
||||
m = re.match(r'^/transcode/(.+?)/master_(\w+)\.m3u8$', path)
|
||||
if m:
|
||||
return self.handle_master_playlist(m.group(1), m.group(2))
|
||||
|
||||
# Stream playlist
|
||||
m = re.match(r'^/transcode/(.+?)/stream_a(\d+)_(\w+)\.m3u8$', path)
|
||||
if m:
|
||||
return self.handle_stream_playlist(m.group(1), int(m.group(2)), m.group(3))
|
||||
|
||||
# Segment
|
||||
m = re.match(r'^/transcode/(.+?)/seg_a(\d+)_(\w+)_(\d+)\.ts$', path)
|
||||
if m:
|
||||
return self.handle_segment(m.group(1), int(m.group(2)), m.group(3), int(m.group(4)))
|
||||
|
||||
# Subtitle playlist
|
||||
m = re.match(r'^/transcode/(.+?)/subtitle_(\d+)\.m3u8$', path)
|
||||
if m:
|
||||
return self.handle_subtitle_playlist(m.group(1), int(m.group(2)))
|
||||
|
||||
# Subtitle VTT
|
||||
m = re.match(r'^/transcode/(.+?)/subtitle_(\d+)\.vtt$', path)
|
||||
if m:
|
||||
return self.handle_subtitle_vtt(m.group(1), int(m.group(2)))
|
||||
|
||||
self.send_error(404)
|
||||
|
||||
def serve_setup_page(self):
|
||||
"""Serve the setup/dashboard page."""
|
||||
html_path = os.path.join(os.path.dirname(__file__), 'www', 'index.html')
|
||||
if not os.path.exists(html_path):
|
||||
# Try parent directory
|
||||
html_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'www', 'index.html')
|
||||
|
||||
if os.path.exists(html_path):
|
||||
with open(html_path, 'r', encoding='utf-8') as f:
|
||||
content = f.read()
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Type', 'text/html')
|
||||
self.send_header('Content-Length', len(content.encode('utf-8')))
|
||||
self.end_headers()
|
||||
self.wfile.write(content.encode('utf-8'))
|
||||
else:
|
||||
# Fallback minimal page
|
||||
content = f"""<!DOCTYPE html>
|
||||
<html>
|
||||
<head><title>Meta-Stremio</title></head>
|
||||
<body style="font-family: sans-serif; background: #1a1a2e; color: #fff; padding: 2rem;">
|
||||
<h1>Meta-Stremio</h1>
|
||||
<p>Install URL: <code>{self.get_base_url()}/manifest.json</code></p>
|
||||
<p><a href="stremio://{self.headers.get('Host', 'localhost')}/manifest.json" style="color: #4dabf7;">Install in Stremio</a></p>
|
||||
</body>
|
||||
</html>"""
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Type', 'text/html')
|
||||
self.end_headers()
|
||||
self.wfile.write(content.encode('utf-8'))
|
||||
|
||||
def serve_configure_page(self):
|
||||
"""Serve the configuration page for language settings."""
|
||||
html_path = os.path.join(os.path.dirname(__file__), 'www', 'configure.html')
|
||||
if not os.path.exists(html_path):
|
||||
html_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'www', 'configure.html')
|
||||
|
||||
if os.path.exists(html_path):
|
||||
with open(html_path, 'r', encoding='utf-8') as f:
|
||||
content = f.read()
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Type', 'text/html')
|
||||
self.send_header('Content-Length', len(content.encode('utf-8')))
|
||||
self.end_headers()
|
||||
self.wfile.write(content.encode('utf-8'))
|
||||
else:
|
||||
# Inline configure page (fallback)
|
||||
base_url = self.get_base_url()
|
||||
host = self.headers.get('Host', 'localhost')
|
||||
languages = stremio.get_supported_languages()
|
||||
|
||||
lang_options = '\n'.join(
|
||||
f'<option value="{code}">{name}</option>'
|
||||
for code, name in languages
|
||||
)
|
||||
|
||||
content = f"""<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>Configure Meta-Stremio</title>
|
||||
<style>
|
||||
:root {{
|
||||
--bg-primary: #0a0a0f;
|
||||
--bg-secondary: #12121a;
|
||||
--bg-tertiary: #1a1a2e;
|
||||
--text-primary: #e0e0e0;
|
||||
--text-secondary: #a0a0a0;
|
||||
--accent-primary: #4ecdc4;
|
||||
--border-color: #2a2a3e;
|
||||
}}
|
||||
* {{ box-sizing: border-box; margin: 0; padding: 0; }}
|
||||
body {{
|
||||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||||
background: var(--bg-primary);
|
||||
color: var(--text-primary);
|
||||
min-height: 100vh;
|
||||
padding: 2rem;
|
||||
display: flex;
|
||||
justify-content: center;
|
||||
align-items: center;
|
||||
}}
|
||||
.container {{
|
||||
max-width: 500px;
|
||||
width: 100%;
|
||||
}}
|
||||
h1 {{
|
||||
font-size: 1.8rem;
|
||||
margin-bottom: 0.5rem;
|
||||
background: linear-gradient(135deg, var(--accent-primary), #ff6b6b);
|
||||
-webkit-background-clip: text;
|
||||
background-clip: text;
|
||||
-webkit-text-fill-color: transparent;
|
||||
}}
|
||||
.subtitle {{ color: var(--text-secondary); margin-bottom: 2rem; }}
|
||||
.card {{
|
||||
background: var(--bg-secondary);
|
||||
border-radius: 12px;
|
||||
padding: 1.5rem;
|
||||
border: 1px solid var(--border-color);
|
||||
margin-bottom: 1.5rem;
|
||||
}}
|
||||
.form-group {{ margin-bottom: 1.5rem; }}
|
||||
.form-group:last-child {{ margin-bottom: 0; }}
|
||||
label {{
|
||||
display: block;
|
||||
margin-bottom: 0.5rem;
|
||||
font-weight: 500;
|
||||
}}
|
||||
.hint {{ font-size: 0.85rem; color: var(--text-secondary); margin-top: 0.25rem; }}
|
||||
select {{
|
||||
width: 100%;
|
||||
padding: 0.75rem;
|
||||
border-radius: 8px;
|
||||
border: 1px solid var(--border-color);
|
||||
background: var(--bg-tertiary);
|
||||
color: var(--text-primary);
|
||||
font-size: 1rem;
|
||||
}}
|
||||
.url-box {{
|
||||
background: var(--bg-tertiary);
|
||||
border-radius: 8px;
|
||||
padding: 1rem;
|
||||
font-family: monospace;
|
||||
font-size: 0.85rem;
|
||||
word-break: break-all;
|
||||
margin-bottom: 1rem;
|
||||
border: 1px solid var(--border-color);
|
||||
color: var(--accent-primary);
|
||||
}}
|
||||
.btn {{
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
gap: 0.5rem;
|
||||
padding: 0.75rem 1.5rem;
|
||||
border-radius: 8px;
|
||||
text-decoration: none;
|
||||
font-weight: 600;
|
||||
font-size: 0.9rem;
|
||||
border: none;
|
||||
cursor: pointer;
|
||||
width: 100%;
|
||||
margin-bottom: 0.75rem;
|
||||
}}
|
||||
.btn-primary {{
|
||||
background: var(--accent-primary);
|
||||
color: var(--bg-primary);
|
||||
}}
|
||||
.btn-secondary {{
|
||||
background: var(--bg-tertiary);
|
||||
color: var(--text-primary);
|
||||
border: 1px solid var(--border-color);
|
||||
}}
|
||||
.warning {{
|
||||
background: rgba(255, 217, 61, 0.15);
|
||||
color: #ffd93d;
|
||||
padding: 0.75rem;
|
||||
border-radius: 8px;
|
||||
font-size: 0.85rem;
|
||||
margin-bottom: 1rem;
|
||||
}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<h1>Configure Meta-Stremio</h1>
|
||||
<p class="subtitle">Set your language preferences for metadata display</p>
|
||||
|
||||
|
||||
<div class="card">
|
||||
<div class="form-group">
|
||||
<label for="displayLang">Display Language</label>
|
||||
<select id="displayLang">
|
||||
{lang_options}
|
||||
</select>
|
||||
<p class="hint">Language preference for titles (uses metadata from meta-sort's TMDB plugin)</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="card">
|
||||
<p style="margin-bottom: 0.5rem; font-weight: 500;">Install URL:</p>
|
||||
<div class="url-box" id="installUrl">{base_url}/manifest.json</div>
|
||||
|
||||
<a href="#" id="installBtn" class="btn btn-primary">Install in Stremio</a>
|
||||
<button onclick="copyUrl()" class="btn btn-secondary">Copy URL</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
const baseUrl = '{base_url}';
|
||||
const host = '{host}';
|
||||
|
||||
function encodeConfig(config) {{
|
||||
const json = JSON.stringify(config);
|
||||
// URL-safe base64 encode
|
||||
const encoded = btoa(json).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');
|
||||
return encoded;
|
||||
}}
|
||||
|
||||
function updateUrl() {{
|
||||
const displayLang = document.getElementById('displayLang').value;
|
||||
|
||||
let url, stremioUrl;
|
||||
if (displayLang === 'en') {{
|
||||
// No config needed for default
|
||||
url = baseUrl + '/manifest.json';
|
||||
stremioUrl = 'stremio://' + host + '/manifest.json';
|
||||
}} else {{
|
||||
const config = {{ displayLanguage: displayLang }};
|
||||
const encoded = encodeConfig(config);
|
||||
url = baseUrl + '/' + encoded + '/manifest.json';
|
||||
stremioUrl = 'stremio://' + host + '/' + encoded + '/manifest.json';
|
||||
}}
|
||||
|
||||
document.getElementById('installUrl').textContent = url;
|
||||
document.getElementById('installBtn').href = stremioUrl;
|
||||
}}
|
||||
|
||||
function copyUrl() {{
|
||||
const url = document.getElementById('installUrl').textContent;
|
||||
navigator.clipboard.writeText(url).then(() => {{
|
||||
const btn = event.target;
|
||||
const original = btn.textContent;
|
||||
btn.textContent = 'Copied!';
|
||||
setTimeout(() => btn.textContent = original, 2000);
|
||||
}});
|
||||
}}
|
||||
|
||||
// Update URL when language changes
|
||||
document.getElementById('displayLang').addEventListener('change', updateUrl);
|
||||
|
||||
// Try to detect browser language
|
||||
const browserLang = navigator.language.split('-')[0];
|
||||
const langSelect = document.getElementById('displayLang');
|
||||
for (const opt of langSelect.options) {{
|
||||
if (opt.value === browserLang) {{
|
||||
opt.selected = true;
|
||||
break;
|
||||
}}
|
||||
}}
|
||||
|
||||
// Initial URL update
|
||||
updateUrl();
|
||||
</script>
|
||||
</body>
|
||||
</html>"""
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Type', 'text/html')
|
||||
self.end_headers()
|
||||
self.wfile.write(content.encode('utf-8'))
|
||||
|
||||
def handle_services_api(self):
|
||||
"""Return list of discovered services for dashboard navigation."""
|
||||
services = []
|
||||
leader_info = None
|
||||
|
||||
try:
|
||||
sd = get_service_discovery()
|
||||
if sd and sd.is_started():
|
||||
all_services = sd.discover_all_services()
|
||||
|
||||
for svc in all_services:
|
||||
# Build dashboard URL from API URL
|
||||
api_url = svc.get('api', '')
|
||||
dashboard_path = svc.get('endpoints', {}).get('dashboard', '/')
|
||||
|
||||
services.append({
|
||||
'name': svc.get('name', 'Unknown'),
|
||||
'url': api_url + dashboard_path if api_url else '',
|
||||
'api': api_url,
|
||||
'status': svc.get('status', 'unknown'),
|
||||
'capabilities': svc.get('capabilities', []),
|
||||
'version': svc.get('version', ''),
|
||||
})
|
||||
except Exception as e:
|
||||
print(f"[Server] Error discovering services: {e}")
|
||||
|
||||
# Get leader info from leader storage
|
||||
try:
|
||||
storage = stremio.get_storage()
|
||||
if storage and hasattr(storage, '_leader_discovery'):
|
||||
discovery = storage._leader_discovery
|
||||
if discovery:
|
||||
info = discovery.get_leader_info()
|
||||
if info:
|
||||
leader_info = {
|
||||
'host': info.host if hasattr(info, 'host') else info.get('host', ''),
|
||||
'api': info.api if hasattr(info, 'api') else info.get('api', ''),
|
||||
'http': info.http if hasattr(info, 'http') else info.get('http', ''),
|
||||
}
|
||||
except Exception as e:
|
||||
print(f"[Server] Error getting leader info: {e}")
|
||||
|
||||
return self.send_json({
|
||||
'services': services,
|
||||
'current': 'meta-stremio',
|
||||
'leader': leader_info,
|
||||
'isLeader': False, # meta-stremio is never the leader
|
||||
})
|
||||
|
||||
def handle_file(self, cid: str, width: int = None):
|
||||
"""Serve a file by CID with optional resizing (for images)."""
|
||||
file_data, content_type, status = fileserver.serve_file(cid, width)
|
||||
|
||||
if status == 200 and file_data:
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Type', content_type)
|
||||
self.send_header('Content-Length', len(file_data))
|
||||
self.send_header('Cache-Control', 'public, max-age=604800') # 7 days
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
self.end_headers()
|
||||
self.wfile.write(file_data)
|
||||
elif status == 404:
|
||||
self.send_error(404, f"File not found: {cid}")
|
||||
else:
|
||||
self.send_error(status, "Error serving file")
|
||||
|
||||
def handle_stremio_manifest(self, config: dict = None):
|
||||
host = self.get_host()
|
||||
# Set base URL for poster URLs in responses
|
||||
stremio.set_base_url(self.get_base_url())
|
||||
data, content_type = stremio_handler.handle_manifest(host, config)
|
||||
self.send_data(data, content_type)
|
||||
|
||||
def get_host(self) -> str:
|
||||
host = self.headers.get('X-Forwarded-Host') or self.headers.get('Host', 'localhost')
|
||||
if ':' in host and not host.startswith('['):
|
||||
host = host.rsplit(':', 1)[0]
|
||||
return host
|
||||
|
||||
def handle_stremio_catalog(self, catalog_type: str, catalog_id: str, extra: str = None, config: dict = None):
|
||||
extra_dict = {}
|
||||
if extra:
|
||||
for param in extra.split('&'):
|
||||
if '=' in param:
|
||||
key, value = param.split('=', 1)
|
||||
extra_dict[key] = unquote(value)
|
||||
|
||||
# Set base URL for poster URLs in responses
|
||||
stremio.set_base_url(self.get_base_url())
|
||||
data, content_type = stremio_handler.handle_catalog(catalog_type, catalog_id, extra_dict, config)
|
||||
self.send_data(data, content_type)
|
||||
|
||||
def handle_stremio_meta(self, meta_type: str, meta_id: str, config: dict = None):
|
||||
# Set base URL for poster URLs in responses
|
||||
stremio.set_base_url(self.get_base_url())
|
||||
data, content_type = stremio_handler.handle_meta(meta_type, meta_id, config)
|
||||
if data:
|
||||
self.send_data(data, content_type)
|
||||
else:
|
||||
self.send_error(404, "Video not found")
|
||||
|
||||
def handle_stremio_stream(self, stream_type: str, stream_id: str, config: dict = None):
|
||||
base_url = self.get_base_url()
|
||||
# Set base URL for poster URLs in responses
|
||||
stremio.set_base_url(base_url)
|
||||
data, content_type = stremio_handler.handle_stream(stream_type, stream_id, base_url, config)
|
||||
if data:
|
||||
self.send_data(data, content_type)
|
||||
else:
|
||||
self.send_error(404, "Video not found")
|
||||
|
||||
# === Transcoder handlers ===
|
||||
|
||||
def get_file_info(self, filepath: str):
|
||||
# Try multiple path resolutions:
|
||||
# 1. Relative to MEDIA_DIR (e.g., /files/watch/filename.mp4)
|
||||
# 2. Absolute path starting with /files/ (e.g., /files/test/filename.mp4)
|
||||
# 3. Prepend /files/ if path looks like files/... (from URL encoding)
|
||||
candidates = [
|
||||
os.path.join(transcoder.MEDIA_DIR, filepath), # Relative to MEDIA_DIR
|
||||
'/' + filepath if not filepath.startswith('/') else filepath, # Make absolute
|
||||
]
|
||||
|
||||
full_path = None
|
||||
for candidate in candidates:
|
||||
if os.path.exists(candidate):
|
||||
full_path = candidate
|
||||
break
|
||||
|
||||
if not full_path:
|
||||
self.send_error(404, f"File not found: {filepath}")
|
||||
return None, None, None
|
||||
|
||||
info = transcoder.get_video_info(full_path)
|
||||
if not info:
|
||||
self.send_error(500, "Could not probe file")
|
||||
return None, None, None
|
||||
|
||||
return full_path, transcoder.get_file_hash(filepath), info
|
||||
|
||||
def handle_master_playlist(self, filepath: str, resolution: str = None, audio: int = None):
|
||||
full_path, file_hash, info = self.get_file_info(filepath)
|
||||
if not info:
|
||||
return
|
||||
|
||||
playlist = transcoder.generate_master_playlist(info, resolution, audio)
|
||||
self.send_data(playlist.encode(), 'application/vnd.apple.mpegurl')
|
||||
|
||||
def handle_stream_playlist(self, filepath: str, audio: int, resolution: str):
|
||||
full_path, file_hash, info = self.get_file_info(filepath)
|
||||
if not info:
|
||||
return
|
||||
|
||||
playlist = transcoder.generate_stream_playlist(info, audio, resolution)
|
||||
self.send_data(playlist.encode(), 'application/vnd.apple.mpegurl')
|
||||
|
||||
def handle_segment(self, filepath: str, audio: int, resolution: str, segment: int):
|
||||
full_path, file_hash, info = self.get_file_info(filepath)
|
||||
if not info:
|
||||
return
|
||||
|
||||
video_codec, audio_codec = transcoder.extract_codecs(info)
|
||||
transcoder.segment_manager.set_codec_info(video_codec, audio_codec, filepath)
|
||||
|
||||
data = transcoder.get_or_transcode_segment(filepath, file_hash, audio, resolution, segment, info)
|
||||
if data:
|
||||
self.send_data(data, 'video/mp2t')
|
||||
else:
|
||||
self.send_error(500, "Transcode failed")
|
||||
|
||||
def handle_subtitle_playlist(self, filepath: str, sub_index: int):
|
||||
full_path, file_hash, info = self.get_file_info(filepath)
|
||||
if not info:
|
||||
return
|
||||
|
||||
playlist = transcoder.generate_subtitle_playlist(info, sub_index)
|
||||
self.send_data(playlist.encode(), 'application/vnd.apple.mpegurl')
|
||||
|
||||
def handle_subtitle_vtt(self, filepath: str, sub_index: int):
|
||||
full_path, file_hash, info = self.get_file_info(filepath)
|
||||
if not info:
|
||||
return
|
||||
|
||||
key = f"{file_hash}:sub:{sub_index}"
|
||||
content, error = transcoder.subtitle_manager.get_subtitle(key, full_path, file_hash, sub_index, info)
|
||||
|
||||
if content:
|
||||
self.send_data(content.encode('utf-8'), 'text/vtt')
|
||||
else:
|
||||
error_vtt = f"WEBVTT\n\nNOTE Subtitle extraction failed: {error or 'Unknown error'}\n"
|
||||
self.send_data(error_vtt.encode('utf-8'), 'text/vtt')
|
||||
|
||||
def handle_direct_file(self, filepath: str):
|
||||
# Try multiple path resolutions (same logic as get_file_info)
|
||||
candidates = [
|
||||
os.path.join(transcoder.MEDIA_DIR, filepath), # Relative to MEDIA_DIR
|
||||
'/' + filepath if not filepath.startswith('/') else filepath, # Make absolute
|
||||
]
|
||||
|
||||
full_path = None
|
||||
for candidate in candidates:
|
||||
if os.path.exists(candidate):
|
||||
full_path = candidate
|
||||
break
|
||||
|
||||
if not full_path:
|
||||
self.send_error(404, f"File not found: {filepath}")
|
||||
return
|
||||
|
||||
ext = os.path.splitext(filepath)[1].lower()
|
||||
content_types = {
|
||||
'.mp4': 'video/mp4',
|
||||
'.mkv': 'video/x-matroska',
|
||||
'.webm': 'video/webm',
|
||||
'.avi': 'video/x-msvideo',
|
||||
'.mov': 'video/quicktime',
|
||||
'.m4v': 'video/x-m4v',
|
||||
'.ts': 'video/mp2t',
|
||||
'.m2ts': 'video/mp2t',
|
||||
}
|
||||
content_type = content_types.get(ext, 'application/octet-stream')
|
||||
|
||||
file_size = os.path.getsize(full_path)
|
||||
range_header = self.headers.get('Range')
|
||||
|
||||
if range_header:
|
||||
range_match = re.match(r'bytes=(\d*)-(\d*)', range_header)
|
||||
if range_match:
|
||||
start = int(range_match.group(1)) if range_match.group(1) else 0
|
||||
end = int(range_match.group(2)) if range_match.group(2) else file_size - 1
|
||||
end = min(end, file_size - 1)
|
||||
length = end - start + 1
|
||||
|
||||
self.send_response(206)
|
||||
self.send_header('Content-Type', content_type)
|
||||
self.send_header('Content-Length', length)
|
||||
self.send_header('Content-Range', f'bytes {start}-{end}/{file_size}')
|
||||
self.send_header('Accept-Ranges', 'bytes')
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
self.end_headers()
|
||||
|
||||
with open(full_path, 'rb') as f:
|
||||
f.seek(start)
|
||||
remaining = length
|
||||
chunk_size = 64 * 1024
|
||||
while remaining > 0:
|
||||
chunk = f.read(min(chunk_size, remaining))
|
||||
if not chunk:
|
||||
break
|
||||
self.wfile.write(chunk)
|
||||
remaining -= len(chunk)
|
||||
return
|
||||
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Type', content_type)
|
||||
self.send_header('Content-Length', file_size)
|
||||
self.send_header('Accept-Ranges', 'bytes')
|
||||
self.send_header('Access-Control-Allow-Origin', '*')
|
||||
self.end_headers()
|
||||
|
||||
with open(full_path, 'rb') as f:
|
||||
chunk_size = 64 * 1024
|
||||
while True:
|
||||
chunk = f.read(chunk_size)
|
||||
if not chunk:
|
||||
break
|
||||
self.wfile.write(chunk)
|
||||
|
||||
def get_base_url(self) -> str:
|
||||
host = self.headers.get('X-Forwarded-Host') or self.headers.get('Host', 'localhost')
|
||||
|
||||
# SCHEME can be 'http', 'https', 'auto', or empty
|
||||
# 'auto' or empty means auto-detect based on host
|
||||
if SCHEME and SCHEME not in ('auto', ''):
|
||||
proto = SCHEME
|
||||
else:
|
||||
is_localhost = 'localhost' in host or '127.0.0.1' in host or '::1' in host
|
||||
proto = 'http' if is_localhost else 'https'
|
||||
|
||||
clean_host = host.replace(':80', '').replace(':443', '')
|
||||
return f"{proto}://{clean_host}"
|
||||
|
||||
|
||||
class ThreadedServer(HTTPServer):
|
||||
def process_request(self, request, client_address):
|
||||
t = threading.Thread(target=self._handle, args=(request, client_address), daemon=True)
|
||||
t.start()
|
||||
|
||||
def _handle(self, request, client_address):
|
||||
try:
|
||||
self.finish_request(request, client_address)
|
||||
except Exception:
|
||||
self.handle_error(request, client_address)
|
||||
finally:
|
||||
self.shutdown_request(request)
|
||||
|
||||
|
||||
def shutdown_handler(signum, frame):
|
||||
"""Handle graceful shutdown."""
|
||||
print("\n[Server] Shutting down...")
|
||||
|
||||
# Stop plugin subscriber
|
||||
try:
|
||||
plugin_subscriber.stop_subscriber()
|
||||
except Exception as e:
|
||||
print(f"[Server] Error stopping plugin subscriber: {e}")
|
||||
|
||||
# Stop service discovery
|
||||
try:
|
||||
sd = get_service_discovery()
|
||||
if sd:
|
||||
sd.stop()
|
||||
except Exception as e:
|
||||
print(f"[Server] Error stopping service discovery: {e}")
|
||||
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
def main():
|
||||
# Register shutdown handlers
|
||||
signal.signal(signal.SIGINT, shutdown_handler)
|
||||
signal.signal(signal.SIGTERM, shutdown_handler)
|
||||
|
||||
storage = stremio.get_storage()
|
||||
storage_type = storage.get_status().get('type', 'unknown')
|
||||
video_count = storage.get_video_count()
|
||||
|
||||
# Initialize fileserver with storage reference
|
||||
fileserver.init(storage)
|
||||
|
||||
# Initialize plugin subscriber to receive notifications when
|
||||
# filename-parser and tmdb plugins complete
|
||||
subscriber = plugin_subscriber.init_subscriber()
|
||||
|
||||
print(f"Meta-Stremio starting on port {PORT}")
|
||||
print(f"Storage: {storage_type} | Videos: {video_count}")
|
||||
print(f"Media: {transcoder.MEDIA_DIR} | Cache: {transcoder.CACHE_DIR}")
|
||||
print(f"Segment: {transcoder.SEGMENT_DURATION}s | Prefetch: {transcoder.PREFETCH_SEGMENTS} segments")
|
||||
print(f"Manifest URL: http://localhost:{PORT}/manifest.json")
|
||||
print(f"Dashboard: http://localhost:{PORT}/")
|
||||
print("Adaptive quality: target 60-80% transcode ratio")
|
||||
|
||||
if service_discovery:
|
||||
print(f"Service discovery: enabled (registered as meta-stremio)")
|
||||
else:
|
||||
print(f"Service discovery: disabled (META_CORE_PATH not found)")
|
||||
|
||||
if subscriber:
|
||||
print(f"Plugin subscriber: enabled (watching: filename-parser, tmdb)")
|
||||
else:
|
||||
print(f"Plugin subscriber: disabled (Redis not available)")
|
||||
|
||||
ThreadedServer(('0.0.0.0', PORT), Handler).serve_forever()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,33 @@
|
||||
"""
|
||||
Storage abstraction layer for meta-stremio.
|
||||
|
||||
Provides a unified interface for reading video metadata from different backends:
|
||||
- LeaderStorage: Discovers and connects to the KV leader (recommended)
|
||||
- RedisStorage: Reads from Redis with direct URL (legacy)
|
||||
|
||||
Also provides service discovery for inter-service communication.
|
||||
"""
|
||||
|
||||
from .provider import StorageProvider, VideoMetadata
|
||||
from .redis_storage import RedisStorage
|
||||
from .leader_storage import LeaderStorage
|
||||
from .leader_discovery import LeaderDiscovery, LeaderLockInfo
|
||||
from .service_discovery import (
|
||||
ServiceDiscovery,
|
||||
ServiceInfo,
|
||||
get_service_discovery,
|
||||
init_service_discovery
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
'StorageProvider',
|
||||
'VideoMetadata',
|
||||
'RedisStorage',
|
||||
'LeaderStorage',
|
||||
'LeaderDiscovery',
|
||||
'LeaderLockInfo',
|
||||
'ServiceDiscovery',
|
||||
'ServiceInfo',
|
||||
'get_service_discovery',
|
||||
'init_service_discovery',
|
||||
]
|
||||
@@ -0,0 +1,300 @@
|
||||
"""
|
||||
Leader Discovery for meta-stremio (FOLLOWER-only)
|
||||
|
||||
This is a Python implementation of the leader discovery pattern used in meta-fuse.
|
||||
meta-stremio never spawns Redis - it only connects to the leader's Redis instance.
|
||||
|
||||
Architecture:
|
||||
- Reads info file at META_CORE_PATH/locks/kv-leader.info
|
||||
- The leader holds flock on kv-leader.lock, writes metadata to kv-leader.info
|
||||
- Parses leader info (Redis URL, HTTP URL)
|
||||
- Watches for leader changes via polling and file watching
|
||||
- Triggers reconnection callbacks on leader failure/change
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import json
|
||||
import time
|
||||
import threading
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
from typing import Optional, Callable
|
||||
from urllib.request import urlopen
|
||||
from urllib.error import URLError
|
||||
|
||||
# Try to import watchdog for file watching (optional)
|
||||
try:
|
||||
from watchdog.observers import Observer
|
||||
from watchdog.events import FileSystemEventHandler
|
||||
WATCHDOG_AVAILABLE = True
|
||||
except ImportError:
|
||||
WATCHDOG_AVAILABLE = False
|
||||
Observer = None
|
||||
FileSystemEventHandler = object
|
||||
|
||||
|
||||
@dataclass
|
||||
class LeaderLockInfo:
|
||||
"""Leader lock file content format."""
|
||||
host: str
|
||||
api: str # Redis connection URL (e.g., redis://10.0.1.50:6379)
|
||||
http: str # HTTP API URL for the leader service
|
||||
timestamp: int
|
||||
pid: int
|
||||
|
||||
|
||||
class LockFileHandler(FileSystemEventHandler):
|
||||
"""File system event handler for lock file changes."""
|
||||
|
||||
def __init__(self, callback: Callable[[], None], lock_filename: str):
|
||||
self.callback = callback
|
||||
self.lock_filename = lock_filename
|
||||
|
||||
def on_modified(self, event):
|
||||
if event.src_path.endswith(self.lock_filename):
|
||||
self.callback()
|
||||
|
||||
def on_created(self, event):
|
||||
if event.src_path.endswith(self.lock_filename):
|
||||
self.callback()
|
||||
|
||||
def on_deleted(self, event):
|
||||
if event.src_path.endswith(self.lock_filename):
|
||||
self.callback()
|
||||
|
||||
|
||||
class LeaderDiscovery:
|
||||
"""
|
||||
Leader Discovery for meta-stremio.
|
||||
|
||||
Discovers and monitors the KV leader via a lock file in the shared filesystem.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
meta_core_path: str,
|
||||
health_check_interval: float = 5.0,
|
||||
max_failures: int = 3
|
||||
):
|
||||
self.meta_core_path = meta_core_path
|
||||
self.health_check_interval = health_check_interval
|
||||
self.max_failures = max_failures
|
||||
|
||||
self.lock_file_path = os.path.join(meta_core_path, 'locks', 'kv-leader.info')
|
||||
self.leader_info: Optional[LeaderLockInfo] = None
|
||||
|
||||
self._is_started = False
|
||||
self._stop_event = threading.Event()
|
||||
self._health_check_thread: Optional[threading.Thread] = None
|
||||
self._file_observer = None
|
||||
self._consecutive_failures = 0
|
||||
|
||||
# Event callbacks
|
||||
self._on_leader_found_callback: Optional[Callable[[LeaderLockInfo], None]] = None
|
||||
self._on_leader_lost_callback: Optional[Callable[[], None]] = None
|
||||
|
||||
def start(self) -> None:
|
||||
"""Start watching for leader."""
|
||||
if self._is_started:
|
||||
print("[LeaderDiscovery] Already started")
|
||||
return
|
||||
|
||||
print(f"[LeaderDiscovery] Starting, lock file: {self.lock_file_path}")
|
||||
|
||||
# Ensure lock directory exists
|
||||
self._ensure_lock_dir()
|
||||
|
||||
# Try to read existing leader info
|
||||
self._check_for_leader()
|
||||
|
||||
# Start file watcher (if watchdog is available)
|
||||
self._start_file_watcher()
|
||||
|
||||
# Start health check thread
|
||||
self._start_health_check()
|
||||
|
||||
self._is_started = True
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop watching."""
|
||||
if not self._is_started:
|
||||
return
|
||||
|
||||
print("[LeaderDiscovery] Stopping...")
|
||||
|
||||
self._stop_event.set()
|
||||
|
||||
# Stop health check thread
|
||||
if self._health_check_thread and self._health_check_thread.is_alive():
|
||||
self._health_check_thread.join(timeout=2.0)
|
||||
|
||||
# Stop file observer
|
||||
if self._file_observer:
|
||||
self._file_observer.stop()
|
||||
self._file_observer.join(timeout=2.0)
|
||||
self._file_observer = None
|
||||
|
||||
self._is_started = False
|
||||
|
||||
def _ensure_lock_dir(self) -> None:
|
||||
"""Ensure lock directory exists."""
|
||||
lock_dir = os.path.dirname(self.lock_file_path)
|
||||
try:
|
||||
os.makedirs(lock_dir, exist_ok=True)
|
||||
except OSError as e:
|
||||
print(f"[LeaderDiscovery] Could not create lock directory: {e}")
|
||||
|
||||
def _check_for_leader(self) -> None:
|
||||
"""Check for leader by reading lock file."""
|
||||
try:
|
||||
with open(self.lock_file_path, 'r') as f:
|
||||
content = f.read()
|
||||
|
||||
data = json.loads(content)
|
||||
|
||||
# Validate leader info
|
||||
if data and data.get('api') and data.get('http'):
|
||||
info = LeaderLockInfo(
|
||||
host=data.get('host', 'unknown'),
|
||||
api=data['api'],
|
||||
http=data['http'],
|
||||
timestamp=data.get('timestamp', 0),
|
||||
pid=data.get('pid', 0)
|
||||
)
|
||||
|
||||
is_new = (
|
||||
self.leader_info is None or
|
||||
self.leader_info.api != info.api
|
||||
)
|
||||
|
||||
self.leader_info = info
|
||||
self._consecutive_failures = 0
|
||||
|
||||
if is_new:
|
||||
print(f"[LeaderDiscovery] Leader found: {info.host} at {info.api}")
|
||||
if self._on_leader_found_callback:
|
||||
self._on_leader_found_callback(info)
|
||||
|
||||
except FileNotFoundError:
|
||||
# Lock file doesn't exist - no leader yet
|
||||
if self.leader_info:
|
||||
print("[LeaderDiscovery] Lock file removed, leader lost")
|
||||
self._handle_leader_lost()
|
||||
|
||||
except json.JSONDecodeError as e:
|
||||
print(f"[LeaderDiscovery] Error parsing lock file: {e}")
|
||||
|
||||
except Exception as e:
|
||||
print(f"[LeaderDiscovery] Error reading lock file: {e}")
|
||||
|
||||
def _is_leader_healthy(self) -> bool:
|
||||
"""Check if current leader is still healthy."""
|
||||
if not self.leader_info:
|
||||
return False
|
||||
|
||||
try:
|
||||
health_url = f"{self.leader_info.http}/health"
|
||||
with urlopen(health_url, timeout=5) as response:
|
||||
return response.status == 200
|
||||
except (URLError, TimeoutError, Exception):
|
||||
return False
|
||||
|
||||
def _handle_leader_lost(self) -> None:
|
||||
"""Handle leader being lost."""
|
||||
self.leader_info = None
|
||||
if self._on_leader_lost_callback:
|
||||
self._on_leader_lost_callback()
|
||||
|
||||
def _start_file_watcher(self) -> None:
|
||||
"""Start watching lock file for changes."""
|
||||
if not WATCHDOG_AVAILABLE:
|
||||
print("[LeaderDiscovery] watchdog not available, using polling only")
|
||||
return
|
||||
|
||||
try:
|
||||
lock_dir = os.path.dirname(self.lock_file_path)
|
||||
handler = LockFileHandler(
|
||||
callback=self._check_for_leader,
|
||||
lock_filename='kv-leader.info'
|
||||
)
|
||||
|
||||
self._file_observer = Observer()
|
||||
self._file_observer.schedule(handler, lock_dir, recursive=False)
|
||||
self._file_observer.start()
|
||||
print(f"[LeaderDiscovery] File watcher started for {lock_dir}")
|
||||
|
||||
except Exception as e:
|
||||
print(f"[LeaderDiscovery] Could not start file watcher: {e}")
|
||||
|
||||
def _start_health_check(self) -> None:
|
||||
"""Start health check loop."""
|
||||
def health_check_loop():
|
||||
while not self._stop_event.is_set():
|
||||
try:
|
||||
if not self.leader_info:
|
||||
# No leader known, try to find one
|
||||
self._check_for_leader()
|
||||
else:
|
||||
# Check if current leader is healthy
|
||||
healthy = self._is_leader_healthy()
|
||||
|
||||
if healthy:
|
||||
self._consecutive_failures = 0
|
||||
else:
|
||||
self._consecutive_failures += 1
|
||||
print(f"[LeaderDiscovery] Leader health check failed ({self._consecutive_failures}/{self.max_failures})")
|
||||
|
||||
if self._consecutive_failures >= self.max_failures:
|
||||
print("[LeaderDiscovery] Leader appears dead, marking as lost")
|
||||
self._handle_leader_lost()
|
||||
|
||||
# Try to find new leader
|
||||
self._check_for_leader()
|
||||
|
||||
except Exception as e:
|
||||
print(f"[LeaderDiscovery] Health check error: {e}")
|
||||
|
||||
self._stop_event.wait(self.health_check_interval)
|
||||
|
||||
self._health_check_thread = threading.Thread(
|
||||
target=health_check_loop,
|
||||
daemon=True,
|
||||
name="leader-health-check"
|
||||
)
|
||||
self._health_check_thread.start()
|
||||
|
||||
# ========================================================================
|
||||
# Event Registration
|
||||
# ========================================================================
|
||||
|
||||
def on_leader_found(self, callback: Callable[[LeaderLockInfo], None]) -> 'LeaderDiscovery':
|
||||
"""Register callback for when leader is found/changed."""
|
||||
self._on_leader_found_callback = callback
|
||||
|
||||
# If we already have leader info, call immediately
|
||||
if self.leader_info:
|
||||
callback(self.leader_info)
|
||||
|
||||
return self
|
||||
|
||||
def on_leader_lost(self, callback: Callable[[], None]) -> 'LeaderDiscovery':
|
||||
"""Register callback for when leader is lost."""
|
||||
self._on_leader_lost_callback = callback
|
||||
return self
|
||||
|
||||
# ========================================================================
|
||||
# Getters
|
||||
# ========================================================================
|
||||
|
||||
def get_leader_info(self) -> Optional[LeaderLockInfo]:
|
||||
"""Get current leader info."""
|
||||
return self.leader_info
|
||||
|
||||
def get_redis_url(self) -> Optional[str]:
|
||||
"""Get Redis URL of current leader."""
|
||||
return self.leader_info.api if self.leader_info else None
|
||||
|
||||
def has_leader(self) -> bool:
|
||||
"""Check if a leader is known."""
|
||||
return self.leader_info is not None
|
||||
@@ -0,0 +1,496 @@
|
||||
"""
|
||||
Leader-aware Storage Provider for meta-stremio.
|
||||
|
||||
Uses leader discovery to automatically connect to the KV leader.
|
||||
Handles reconnection when the leader changes or becomes unavailable.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import threading
|
||||
from typing import List, Optional, Callable
|
||||
|
||||
from .provider import StorageProvider, VideoMetadata
|
||||
from .leader_discovery import LeaderDiscovery, LeaderLockInfo
|
||||
|
||||
try:
|
||||
import redis
|
||||
REDIS_AVAILABLE = True
|
||||
except ImportError:
|
||||
REDIS_AVAILABLE = False
|
||||
redis = None
|
||||
|
||||
|
||||
# Configuration from environment
|
||||
META_CORE_PATH = os.environ.get('META_CORE_PATH', '/meta-core')
|
||||
FILES_PATH = os.environ.get('FILES_PATH', '/files')
|
||||
REDIS_PREFIX = os.environ.get('REDIS_PREFIX', 'meta-sort:')
|
||||
|
||||
|
||||
class LeaderStorage(StorageProvider):
|
||||
"""
|
||||
Storage provider that discovers and connects to the KV leader.
|
||||
|
||||
Uses leader discovery to automatically find the Redis instance
|
||||
managed by meta-sort. Handles reconnection on leader failure.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
meta_core_path: str = None,
|
||||
files_path: str = None,
|
||||
prefix: str = None,
|
||||
redis_url: str = None # Override - skip leader discovery
|
||||
):
|
||||
if not REDIS_AVAILABLE:
|
||||
raise ImportError("redis package not installed. Run: pip install redis")
|
||||
|
||||
self._meta_core_path = meta_core_path or META_CORE_PATH
|
||||
self._files_path = files_path or FILES_PATH
|
||||
self._prefix = prefix or REDIS_PREFIX
|
||||
self._override_url = redis_url # Direct Redis URL (skip leader discovery)
|
||||
|
||||
self._leader_discovery: Optional[LeaderDiscovery] = None
|
||||
self._client: Optional[redis.Redis] = None
|
||||
self._connected = False
|
||||
self._lock = threading.Lock()
|
||||
|
||||
# Callbacks
|
||||
self._on_ready_callbacks: List[Callable[[], None]] = []
|
||||
self._on_disconnect_callbacks: List[Callable[[], None]] = []
|
||||
|
||||
def connect(self) -> None:
|
||||
"""Connect to the storage backend via leader discovery."""
|
||||
# If direct URL provided, skip leader discovery
|
||||
if self._override_url:
|
||||
print(f"[LeaderStorage] Using direct Redis URL: {self._override_url}")
|
||||
self._connect_to_redis(self._override_url)
|
||||
return
|
||||
|
||||
# Use leader discovery
|
||||
self._leader_discovery = LeaderDiscovery(
|
||||
meta_core_path=self._meta_core_path
|
||||
)
|
||||
|
||||
# Set up callbacks
|
||||
self._leader_discovery.on_leader_found(self._on_leader_found)
|
||||
self._leader_discovery.on_leader_lost(self._on_leader_lost)
|
||||
|
||||
# Start discovery
|
||||
self._leader_discovery.start()
|
||||
|
||||
def disconnect(self) -> None:
|
||||
"""Disconnect from the storage backend."""
|
||||
# Stop leader discovery
|
||||
if self._leader_discovery:
|
||||
self._leader_discovery.stop()
|
||||
self._leader_discovery = None
|
||||
|
||||
# Disconnect Redis
|
||||
self._disconnect_redis()
|
||||
|
||||
def is_connected(self) -> bool:
|
||||
"""Check if connected to the storage backend."""
|
||||
with self._lock:
|
||||
if not self._connected or not self._client:
|
||||
return False
|
||||
try:
|
||||
self._client.ping()
|
||||
return True
|
||||
except Exception:
|
||||
self._connected = False
|
||||
return False
|
||||
|
||||
def _on_leader_found(self, info: LeaderLockInfo) -> None:
|
||||
"""Handle leader found event."""
|
||||
print(f"[LeaderStorage] Connecting to leader at {info.api}...")
|
||||
self._connect_to_redis(info.api)
|
||||
|
||||
def _on_leader_lost(self) -> None:
|
||||
"""Handle leader lost event."""
|
||||
print("[LeaderStorage] Leader lost, disconnecting...")
|
||||
self._disconnect_redis()
|
||||
self._notify_disconnect()
|
||||
|
||||
def _connect_to_redis(self, url: str) -> None:
|
||||
"""Connect to Redis."""
|
||||
with self._lock:
|
||||
try:
|
||||
# Disconnect existing client
|
||||
self._disconnect_redis_unlocked()
|
||||
|
||||
# Create new client
|
||||
self._client = redis.from_url(url, decode_responses=True)
|
||||
self._client.ping() # Test connection
|
||||
self._connected = True
|
||||
|
||||
print(f"[LeaderStorage] Connected to Redis at {url}")
|
||||
|
||||
# Notify ready
|
||||
self._notify_ready()
|
||||
|
||||
except Exception as e:
|
||||
print(f"[LeaderStorage] Failed to connect to Redis: {e}")
|
||||
self._client = None
|
||||
self._connected = False
|
||||
|
||||
def _disconnect_redis(self) -> None:
|
||||
"""Disconnect from Redis."""
|
||||
with self._lock:
|
||||
self._disconnect_redis_unlocked()
|
||||
|
||||
def _disconnect_redis_unlocked(self) -> None:
|
||||
"""Disconnect from Redis (without lock)."""
|
||||
if self._client:
|
||||
try:
|
||||
self._client.close()
|
||||
except Exception:
|
||||
pass
|
||||
self._client = None
|
||||
self._connected = False
|
||||
|
||||
def _notify_ready(self) -> None:
|
||||
"""Notify ready callbacks."""
|
||||
for callback in self._on_ready_callbacks:
|
||||
try:
|
||||
callback()
|
||||
except Exception as e:
|
||||
print(f"[LeaderStorage] Error in ready callback: {e}")
|
||||
|
||||
def _notify_disconnect(self) -> None:
|
||||
"""Notify disconnect callbacks."""
|
||||
for callback in self._on_disconnect_callbacks:
|
||||
try:
|
||||
callback()
|
||||
except Exception as e:
|
||||
print(f"[LeaderStorage] Error in disconnect callback: {e}")
|
||||
|
||||
# ========================================================================
|
||||
# Event Registration
|
||||
# ========================================================================
|
||||
|
||||
def on_ready(self, callback: Callable[[], None]) -> 'LeaderStorage':
|
||||
"""Register callback for when storage is ready."""
|
||||
self._on_ready_callbacks.append(callback)
|
||||
if self._connected:
|
||||
callback()
|
||||
return self
|
||||
|
||||
def on_disconnect(self, callback: Callable[[], None]) -> 'LeaderStorage':
|
||||
"""Register callback for disconnection."""
|
||||
self._on_disconnect_callbacks.append(callback)
|
||||
return self
|
||||
|
||||
# ========================================================================
|
||||
# Key Schema Helpers
|
||||
# ========================================================================
|
||||
|
||||
def _get_file_key(self, hash_id: str) -> str:
|
||||
"""Get the Redis key for a file hash."""
|
||||
return f"{self._prefix}file:{hash_id}"
|
||||
|
||||
def _resolve_path(self, path: str) -> str:
|
||||
"""Resolve path by prepending FILES_PATH if needed."""
|
||||
if not path:
|
||||
return path
|
||||
if path.startswith(self._files_path):
|
||||
return path
|
||||
if path.startswith('/'):
|
||||
return f"{self._files_path}{path}"
|
||||
return f"{self._files_path}/{path}"
|
||||
|
||||
def _parse_nested_array(self, data: dict, prefix: str) -> list:
|
||||
"""Parse nested array format (prefix/0, prefix/1, etc.) into a list."""
|
||||
items = []
|
||||
index = 0
|
||||
while True:
|
||||
key = f'{prefix}/{index}'
|
||||
if key in data:
|
||||
items.append(data[key])
|
||||
index += 1
|
||||
else:
|
||||
break
|
||||
return items
|
||||
|
||||
def _parse_video(self, hash_id: str, data: dict) -> Optional[VideoMetadata]:
|
||||
"""Parse Redis hash data into VideoMetadata.
|
||||
|
||||
Handles both flat keys and nested keys (e.g., 'plot/eng' for description).
|
||||
meta-sort stores data using a flattened nested key format.
|
||||
"""
|
||||
if not data:
|
||||
return None
|
||||
|
||||
import json as jsonlib
|
||||
|
||||
# Parse JSON fields
|
||||
audio_tracks = []
|
||||
subtitles = []
|
||||
genres = []
|
||||
studios = []
|
||||
|
||||
if 'audioTracks' in data:
|
||||
try:
|
||||
audio_tracks = jsonlib.loads(data['audioTracks'])
|
||||
except (jsonlib.JSONDecodeError, TypeError):
|
||||
pass
|
||||
|
||||
if 'subtitles' in data:
|
||||
try:
|
||||
subtitles = jsonlib.loads(data['subtitles'])
|
||||
except (jsonlib.JSONDecodeError, TypeError):
|
||||
pass
|
||||
|
||||
# Parse genres - can be JSON array or nested keys (genres/0, genres/1, etc.)
|
||||
if 'genres' in data:
|
||||
try:
|
||||
genres = jsonlib.loads(data['genres'])
|
||||
except (jsonlib.JSONDecodeError, TypeError):
|
||||
if isinstance(data['genres'], str):
|
||||
genres = [g.strip() for g in data['genres'].split(',') if g.strip()]
|
||||
else:
|
||||
# Try nested key format (genres/0, genres/1, etc.)
|
||||
genres = self._parse_nested_array(data, 'genres')
|
||||
|
||||
# Parse studios - nested keys (studio/0, studio/1, etc.)
|
||||
studios = self._parse_nested_array(data, 'studio')
|
||||
|
||||
# Parse numeric fields
|
||||
def parse_int(val):
|
||||
try:
|
||||
return int(val) if val else None
|
||||
except (ValueError, TypeError):
|
||||
return None
|
||||
|
||||
def parse_float(val):
|
||||
try:
|
||||
return float(val) if val else None
|
||||
except (ValueError, TypeError):
|
||||
return None
|
||||
|
||||
# Resolve file path with FILES_PATH
|
||||
file_path = data.get('filePath', data.get('sourcePath', ''))
|
||||
resolved_path = self._resolve_path(file_path)
|
||||
|
||||
# Normalize video type: 'tvshow' -> 'series' for Stremio compatibility
|
||||
raw_type = data.get('type', data.get('videoType', 'movie'))
|
||||
video_type = 'series' if raw_type == 'tvshow' else raw_type
|
||||
|
||||
# Get description from nested plot/eng or flat description/plot
|
||||
description = data.get('description')
|
||||
if not description:
|
||||
description = data.get('plot')
|
||||
if not description:
|
||||
# Try nested format: plot/eng, plot/en, etc.
|
||||
for lang in ['eng', 'en', 'english', 'und']:
|
||||
description = data.get(f'plot/{lang}')
|
||||
if description:
|
||||
break
|
||||
|
||||
# Parse rating (stored as string by TMDBProcessor)
|
||||
rating = parse_float(data.get('rating'))
|
||||
|
||||
# Parse release date
|
||||
release_date = data.get('releasedate', data.get('releaseDate'))
|
||||
|
||||
# Parse episode title - try episodeTitle or extract from titles/eng
|
||||
episode_title = data.get('episodeTitle', data.get('episodeName'))
|
||||
if not episode_title:
|
||||
episode_title = data.get('titles/eng', data.get('titles/en'))
|
||||
|
||||
# Parse tagline
|
||||
tagline = data.get('tagline')
|
||||
|
||||
return VideoMetadata(
|
||||
hash_id=hash_id,
|
||||
file_path=resolved_path,
|
||||
title=data.get('title', data.get('originalTitle', '')),
|
||||
video_type=video_type,
|
||||
year=parse_int(data.get('year', data.get('movieYear'))),
|
||||
season=parse_int(data.get('season')),
|
||||
episode=parse_int(data.get('episode')),
|
||||
duration=parse_float(data.get('duration', data.get('fileinfo/duration'))),
|
||||
width=parse_int(data.get('width', data.get('fileinfo/streamdetails/video/0/width'))),
|
||||
height=parse_int(data.get('height', data.get('fileinfo/streamdetails/video/0/height'))),
|
||||
video_codec=data.get('videoCodec', data.get('fileinfo/streamdetails/video/0/codec')),
|
||||
audio_codec=data.get('audioCodec', data.get('fileinfo/streamdetails/audio/0/codec')),
|
||||
container=data.get('container'),
|
||||
file_size=parse_int(data.get('fileSize', data.get('sizeByte'))),
|
||||
audio_tracks=audio_tracks,
|
||||
subtitles=subtitles,
|
||||
imdb_id=data.get('imdbId', data.get('imdbid')),
|
||||
tmdb_id=data.get('tmdbId', data.get('tmdbid')),
|
||||
poster=data.get('poster') or data.get('posterUrl'), # Fallback to posterUrl for backward compat
|
||||
backdrop=data.get('backdrop') or data.get('backdropUrl'), # Fallback to backdropUrl
|
||||
poster_path=data.get('posterPath'),
|
||||
backdrop_path=data.get('backdropPath'),
|
||||
description=description,
|
||||
genres=genres,
|
||||
episode_title=episode_title,
|
||||
rating=rating,
|
||||
release_date=release_date,
|
||||
tagline=tagline,
|
||||
studios=studios,
|
||||
)
|
||||
|
||||
# ========================================================================
|
||||
# StorageProvider Interface
|
||||
# ========================================================================
|
||||
|
||||
def get_all_videos(self) -> List[VideoMetadata]:
|
||||
"""Get all videos from storage."""
|
||||
if not self.is_connected():
|
||||
return []
|
||||
|
||||
videos = []
|
||||
pattern = f"{self._prefix}file:*"
|
||||
|
||||
try:
|
||||
for key in self._client.scan_iter(pattern, count=100):
|
||||
# Skip index key
|
||||
if '__index__' in key:
|
||||
continue
|
||||
|
||||
# Check file type - only include video files
|
||||
file_type = self._client.hget(key, 'fileType')
|
||||
if file_type != 'video':
|
||||
continue
|
||||
|
||||
hash_id = key.replace(f"{self._prefix}file:", "")
|
||||
data = self._client.hgetall(key)
|
||||
video = self._parse_video(hash_id, data)
|
||||
if video and video.file_path:
|
||||
videos.append(video)
|
||||
|
||||
except Exception as e:
|
||||
print(f"[LeaderStorage] Error getting all videos: {e}")
|
||||
|
||||
# Sort by title
|
||||
videos.sort(key=lambda v: v.title.lower())
|
||||
return videos
|
||||
|
||||
def get_video_by_hash(self, hash_id: str) -> Optional[VideoMetadata]:
|
||||
"""Get a video by its hash ID."""
|
||||
if not self.is_connected():
|
||||
return None
|
||||
|
||||
try:
|
||||
key = self._get_file_key(hash_id)
|
||||
data = self._client.hgetall(key)
|
||||
return self._parse_video(hash_id, data)
|
||||
except Exception as e:
|
||||
print(f"[LeaderStorage] Error getting video {hash_id}: {e}")
|
||||
return None
|
||||
|
||||
def get_videos_by_type(self, video_type: str) -> List[VideoMetadata]:
|
||||
"""Get all videos of a specific type."""
|
||||
videos = self.get_all_videos()
|
||||
return [v for v in videos if v.video_type == video_type]
|
||||
|
||||
def search_videos(self, query: str) -> List[VideoMetadata]:
|
||||
"""Search videos by title."""
|
||||
if not query:
|
||||
return self.get_all_videos()
|
||||
|
||||
query_lower = query.lower()
|
||||
videos = self.get_all_videos()
|
||||
return [v for v in videos if query_lower in v.title.lower()]
|
||||
|
||||
def get_video_by_imdb_id(self, imdb_id: str) -> Optional[VideoMetadata]:
|
||||
"""Get a video by its IMDB ID (e.g., 'tt1727587')."""
|
||||
if not self.is_connected() or not imdb_id:
|
||||
return None
|
||||
|
||||
# Normalize IMDB ID format
|
||||
imdb_id = imdb_id.lower()
|
||||
if not imdb_id.startswith('tt'):
|
||||
imdb_id = f"tt{imdb_id}"
|
||||
|
||||
try:
|
||||
# Scan all videos looking for matching IMDB ID
|
||||
pattern = f"{self._prefix}file:*"
|
||||
for key in self._client.scan_iter(pattern, count=100):
|
||||
if '__index__' in key:
|
||||
continue
|
||||
|
||||
# Check imdbid/imdbId field
|
||||
stored_imdb = self._client.hget(key, 'imdbid') or self._client.hget(key, 'imdbId')
|
||||
if stored_imdb and stored_imdb.lower() == imdb_id:
|
||||
hash_id = key.replace(f"{self._prefix}file:", "")
|
||||
data = self._client.hgetall(key)
|
||||
return self._parse_video(hash_id, data)
|
||||
|
||||
except Exception as e:
|
||||
print(f"[LeaderStorage] Error finding video by IMDB ID {imdb_id}: {e}")
|
||||
|
||||
return None
|
||||
|
||||
def get_video_count(self) -> int:
|
||||
"""Get total number of videos."""
|
||||
if not self.is_connected():
|
||||
return 0
|
||||
|
||||
try:
|
||||
# Try index first
|
||||
index_key = f"{self._prefix}file:__index__"
|
||||
count = self._client.scard(index_key)
|
||||
if count > 0:
|
||||
return count
|
||||
|
||||
# Fallback to scanning
|
||||
pattern = f"{self._prefix}file:*"
|
||||
count = 0
|
||||
for key in self._client.scan_iter(pattern, count=100):
|
||||
if '__index__' not in key:
|
||||
count += 1
|
||||
return count
|
||||
|
||||
except Exception as e:
|
||||
print(f"[LeaderStorage] Error counting videos: {e}")
|
||||
return 0
|
||||
|
||||
def get_status(self) -> dict:
|
||||
"""Get storage status for dashboard."""
|
||||
leader_info = None
|
||||
if self._leader_discovery:
|
||||
info = self._leader_discovery.get_leader_info()
|
||||
if info:
|
||||
leader_info = {
|
||||
'host': info.host,
|
||||
'api': info.api,
|
||||
'http': info.http,
|
||||
}
|
||||
|
||||
status = {
|
||||
'type': 'leader',
|
||||
'connected': self.is_connected(),
|
||||
'meta_core_path': self._meta_core_path,
|
||||
'files_path': self._files_path,
|
||||
'prefix': self._prefix,
|
||||
'video_count': 0,
|
||||
'leader': leader_info,
|
||||
}
|
||||
|
||||
if status['connected']:
|
||||
try:
|
||||
status['video_count'] = self.get_video_count()
|
||||
info = self._client.info('memory')
|
||||
status['memory_used'] = info.get('used_memory_human', 'N/A')
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return status
|
||||
|
||||
# ========================================================================
|
||||
# Pub/Sub (Future enhancement)
|
||||
# ========================================================================
|
||||
|
||||
def on_video_added(self, callback: Callable[[VideoMetadata], None]) -> None:
|
||||
"""Subscribe to video added events."""
|
||||
# TODO: Implement pub/sub for real-time updates
|
||||
pass
|
||||
|
||||
def on_video_removed(self, callback: Callable[[str], None]) -> None:
|
||||
"""Subscribe to video removed events."""
|
||||
# TODO: Implement pub/sub for real-time updates
|
||||
pass
|
||||
@@ -0,0 +1,148 @@
|
||||
"""
|
||||
Abstract StorageProvider interface for video metadata.
|
||||
|
||||
meta-stremio is a read-only consumer - it does NOT write metadata.
|
||||
All writes are handled by meta-sort.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from abc import ABC, abstractmethod
|
||||
from dataclasses import dataclass, field
|
||||
from typing import List, Optional, Callable
|
||||
|
||||
|
||||
@dataclass
|
||||
class VideoMetadata:
|
||||
"""Video metadata stored in KV by meta-sort, read by meta-stremio."""
|
||||
hash_id: str
|
||||
file_path: str
|
||||
title: str
|
||||
video_type: str = 'movie' # 'movie' | 'series' | 'anime'
|
||||
year: Optional[int] = None
|
||||
season: Optional[int] = None
|
||||
episode: Optional[int] = None
|
||||
duration: Optional[float] = None
|
||||
width: Optional[int] = None
|
||||
height: Optional[int] = None
|
||||
video_codec: Optional[str] = None
|
||||
audio_codec: Optional[str] = None
|
||||
container: Optional[str] = None
|
||||
file_size: Optional[int] = None
|
||||
audio_tracks: List[dict] = field(default_factory=list)
|
||||
subtitles: List[dict] = field(default_factory=list)
|
||||
imdb_id: Optional[str] = None
|
||||
tmdb_id: Optional[str] = None
|
||||
poster: Optional[str] = None
|
||||
backdrop: Optional[str] = None
|
||||
poster_path: Optional[str] = None
|
||||
backdrop_path: Optional[str] = None
|
||||
description: Optional[str] = None
|
||||
genres: List[str] = field(default_factory=list)
|
||||
# New fields for improved listings
|
||||
episode_title: Optional[str] = None # Title specific to this episode
|
||||
rating: Optional[float] = None # TMDB/IMDB rating (0-10)
|
||||
release_date: Optional[str] = None # Full release date (YYYY-MM-DD)
|
||||
tagline: Optional[str] = None # Movie/series tagline
|
||||
studios: List[str] = field(default_factory=list) # Production studios
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
"""Convert to dictionary for JSON serialization."""
|
||||
return {
|
||||
'hash_id': self.hash_id,
|
||||
'file_path': self.file_path,
|
||||
'title': self.title,
|
||||
'video_type': self.video_type,
|
||||
'year': self.year,
|
||||
'season': self.season,
|
||||
'episode': self.episode,
|
||||
'duration': self.duration,
|
||||
'width': self.width,
|
||||
'height': self.height,
|
||||
'video_codec': self.video_codec,
|
||||
'audio_codec': self.audio_codec,
|
||||
'container': self.container,
|
||||
'file_size': self.file_size,
|
||||
'audio_tracks': self.audio_tracks,
|
||||
'subtitles': self.subtitles,
|
||||
'imdb_id': self.imdb_id,
|
||||
'tmdb_id': self.tmdb_id,
|
||||
'poster': self.poster,
|
||||
'backdrop': self.backdrop,
|
||||
'poster_path': self.poster_path,
|
||||
'backdrop_path': self.backdrop_path,
|
||||
'description': self.description,
|
||||
'genres': self.genres,
|
||||
'episode_title': self.episode_title,
|
||||
'rating': self.rating,
|
||||
'release_date': self.release_date,
|
||||
'tagline': self.tagline,
|
||||
'studios': self.studios,
|
||||
}
|
||||
|
||||
|
||||
class StorageProvider(ABC):
|
||||
"""
|
||||
Abstract interface for video metadata storage.
|
||||
|
||||
meta-stremio only reads - all writes are handled by meta-sort.
|
||||
"""
|
||||
|
||||
@abstractmethod
|
||||
def connect(self) -> None:
|
||||
"""Connect to the storage backend."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def disconnect(self) -> None:
|
||||
"""Disconnect from the storage backend."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def is_connected(self) -> bool:
|
||||
"""Check if connected to the storage backend."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_all_videos(self) -> List[VideoMetadata]:
|
||||
"""Get all videos from storage."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_video_by_hash(self, hash_id: str) -> Optional[VideoMetadata]:
|
||||
"""Get a video by its hash ID."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_videos_by_type(self, video_type: str) -> List[VideoMetadata]:
|
||||
"""Get all videos of a specific type (movie, series, anime)."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def search_videos(self, query: str) -> List[VideoMetadata]:
|
||||
"""Search videos by title."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_video_by_imdb_id(self, imdb_id: str) -> Optional[VideoMetadata]:
|
||||
"""Get a video by its IMDB ID (e.g., 'tt1727587')."""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_video_count(self) -> int:
|
||||
"""Get total number of videos in storage."""
|
||||
pass
|
||||
|
||||
def on_video_added(self, callback: Callable[[VideoMetadata], None]) -> None:
|
||||
"""Subscribe to video added events (optional)."""
|
||||
pass
|
||||
|
||||
def on_video_removed(self, callback: Callable[[str], None]) -> None:
|
||||
"""Subscribe to video removed events (optional)."""
|
||||
pass
|
||||
|
||||
def get_status(self) -> dict:
|
||||
"""Get storage status for dashboard."""
|
||||
return {
|
||||
'connected': self.is_connected(),
|
||||
'video_count': self.get_video_count() if self.is_connected() else 0,
|
||||
}
|
||||
@@ -0,0 +1,379 @@
|
||||
"""
|
||||
Redis storage provider for meta-stremio.
|
||||
|
||||
Reads video metadata from Redis (written by meta-sort).
|
||||
Uses the same key schema as meta-sort for compatibility.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import json
|
||||
from typing import List, Optional
|
||||
|
||||
try:
|
||||
import redis
|
||||
REDIS_AVAILABLE = True
|
||||
except ImportError:
|
||||
REDIS_AVAILABLE = False
|
||||
redis = None
|
||||
|
||||
from .provider import StorageProvider, VideoMetadata
|
||||
|
||||
|
||||
# Redis configuration
|
||||
REDIS_URL = os.environ.get('REDIS_URL', 'redis://localhost:6379')
|
||||
REDIS_PREFIX = os.environ.get('REDIS_PREFIX', 'meta-sort:')
|
||||
|
||||
|
||||
class RedisStorage(StorageProvider):
|
||||
"""
|
||||
Redis storage provider.
|
||||
|
||||
Reads video metadata from Redis using the meta-sort key schema:
|
||||
- meta-sort:file:{hashId} -> Hash containing all metadata fields
|
||||
"""
|
||||
|
||||
def __init__(self, url: str = None, prefix: str = None):
|
||||
if not REDIS_AVAILABLE:
|
||||
raise ImportError("redis package not installed. Run: pip install redis")
|
||||
|
||||
self._url = url or REDIS_URL
|
||||
self._prefix = prefix or REDIS_PREFIX
|
||||
self._client: Optional[redis.Redis] = None
|
||||
self._connected = False
|
||||
|
||||
def connect(self) -> None:
|
||||
"""Connect to Redis."""
|
||||
try:
|
||||
self._client = redis.from_url(self._url, decode_responses=True)
|
||||
# Test connection
|
||||
self._client.ping()
|
||||
self._connected = True
|
||||
print(f"[RedisStorage] Connected to {self._url}")
|
||||
except Exception as e:
|
||||
self._connected = False
|
||||
print(f"[RedisStorage] Failed to connect: {e}")
|
||||
raise
|
||||
|
||||
def disconnect(self) -> None:
|
||||
"""Disconnect from Redis."""
|
||||
if self._client:
|
||||
self._client.close()
|
||||
self._client = None
|
||||
self._connected = False
|
||||
print("[RedisStorage] Disconnected")
|
||||
|
||||
def is_connected(self) -> bool:
|
||||
"""Check if connected to Redis."""
|
||||
if not self._connected or not self._client:
|
||||
return False
|
||||
try:
|
||||
self._client.ping()
|
||||
return True
|
||||
except Exception:
|
||||
self._connected = False
|
||||
return False
|
||||
|
||||
def get_file_path_by_cid(self, cid: str) -> Optional[str]:
|
||||
"""
|
||||
Get the file path for a file by its CID.
|
||||
|
||||
Looks up file:{cid} in Redis and returns the path.
|
||||
Tries 'path' field first, then falls back to 'filePath'.
|
||||
This works for any file including poster images.
|
||||
|
||||
Returns the relative path if found, None otherwise.
|
||||
"""
|
||||
if not self.is_connected():
|
||||
return None
|
||||
|
||||
try:
|
||||
key = self._get_file_key(cid)
|
||||
# Try 'path' field first (relative path)
|
||||
path = self._client.hget(key, 'path')
|
||||
if path:
|
||||
return path
|
||||
# Fall back to 'filePath' (full path from meta-sort)
|
||||
file_path = self._client.hget(key, 'filePath')
|
||||
if file_path:
|
||||
# Convert absolute path to relative by removing /files/ prefix
|
||||
if file_path.startswith('/files/'):
|
||||
return file_path[7:] # Remove '/files/'
|
||||
return file_path
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f"[RedisStorage] Error getting path for CID {cid}: {e}")
|
||||
return None
|
||||
|
||||
def _get_file_key(self, hash_id: str) -> str:
|
||||
"""Get the Redis key for a file hash."""
|
||||
return f"{self._prefix}file:{hash_id}"
|
||||
|
||||
def _parse_video(self, hash_id: str, data: dict) -> Optional[VideoMetadata]:
|
||||
"""Parse Redis hash data into VideoMetadata.
|
||||
|
||||
Handles both flat keys and nested keys (e.g., 'plot/eng' for description).
|
||||
meta-sort stores data using a flattened nested key format.
|
||||
"""
|
||||
if not data:
|
||||
return None
|
||||
|
||||
# Parse JSON fields
|
||||
audio_tracks = []
|
||||
subtitles = []
|
||||
genres = []
|
||||
studios = []
|
||||
|
||||
if 'audioTracks' in data:
|
||||
try:
|
||||
audio_tracks = json.loads(data['audioTracks'])
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
pass
|
||||
|
||||
if 'subtitles' in data:
|
||||
try:
|
||||
subtitles = json.loads(data['subtitles'])
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
pass
|
||||
|
||||
# Parse genres - can be JSON array or nested keys (genres/0, genres/1, etc.)
|
||||
if 'genres' in data:
|
||||
try:
|
||||
genres = json.loads(data['genres'])
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
if isinstance(data['genres'], str):
|
||||
genres = [g.strip() for g in data['genres'].split(',') if g.strip()]
|
||||
else:
|
||||
# Try nested key format (genres/0, genres/1, etc.)
|
||||
genres = self._parse_nested_array(data, 'genres')
|
||||
|
||||
# Parse studios - nested keys (studio/0, studio/1, etc.)
|
||||
studios = self._parse_nested_array(data, 'studio')
|
||||
|
||||
# Parse numeric fields
|
||||
def parse_int(val):
|
||||
try:
|
||||
return int(val) if val else None
|
||||
except (ValueError, TypeError):
|
||||
return None
|
||||
|
||||
def parse_float(val):
|
||||
try:
|
||||
return float(val) if val else None
|
||||
except (ValueError, TypeError):
|
||||
return None
|
||||
|
||||
# Get description from nested plot/eng or flat description/plot
|
||||
description = data.get('description')
|
||||
if not description:
|
||||
description = data.get('plot')
|
||||
if not description:
|
||||
# Try nested format: plot/eng, plot/en, etc.
|
||||
for lang in ['eng', 'en', 'english', 'und']:
|
||||
description = data.get(f'plot/{lang}')
|
||||
if description:
|
||||
break
|
||||
|
||||
# Parse rating (stored as string by TMDBProcessor)
|
||||
rating = parse_float(data.get('rating'))
|
||||
|
||||
# Parse release date
|
||||
release_date = data.get('releasedate', data.get('releaseDate'))
|
||||
|
||||
# Parse episode title (for series episodes)
|
||||
episode_title = data.get('episodeTitle', data.get('episodeName'))
|
||||
|
||||
# Parse tagline
|
||||
tagline = data.get('tagline')
|
||||
|
||||
# Get video/audio codec and resolution from various field formats
|
||||
# meta-sort stores these in fileinfo/streamdetails/video/0/... format
|
||||
video_codec = data.get('videoCodec')
|
||||
if not video_codec:
|
||||
video_codec = data.get('fileinfo/streamdetails/video/0/codec')
|
||||
|
||||
audio_codec = data.get('audioCodec')
|
||||
if not audio_codec:
|
||||
audio_codec = data.get('fileinfo/streamdetails/audio/0/codec')
|
||||
|
||||
width = parse_int(data.get('width'))
|
||||
if not width:
|
||||
width = parse_int(data.get('fileinfo/streamdetails/video/0/width'))
|
||||
|
||||
height = parse_int(data.get('height'))
|
||||
if not height:
|
||||
height = parse_int(data.get('fileinfo/streamdetails/video/0/height'))
|
||||
|
||||
duration = parse_float(data.get('duration'))
|
||||
if not duration:
|
||||
duration = parse_float(data.get('fileinfo/duration'))
|
||||
|
||||
return VideoMetadata(
|
||||
hash_id=hash_id,
|
||||
file_path=data.get('filePath', ''),
|
||||
title=data.get('title', data.get('originalTitle', '')),
|
||||
video_type=data.get('type', data.get('videoType', 'movie')),
|
||||
year=parse_int(data.get('year', data.get('movieYear'))),
|
||||
season=parse_int(data.get('season')),
|
||||
episode=parse_int(data.get('episode')),
|
||||
duration=duration,
|
||||
width=width,
|
||||
height=height,
|
||||
video_codec=video_codec,
|
||||
audio_codec=audio_codec,
|
||||
container=data.get('container'),
|
||||
file_size=parse_int(data.get('fileSize', data.get('sizeByte'))),
|
||||
audio_tracks=audio_tracks,
|
||||
subtitles=subtitles,
|
||||
imdb_id=data.get('imdbId', data.get('imdbid')),
|
||||
tmdb_id=data.get('tmdbId', data.get('tmdbid')),
|
||||
poster=data.get('poster') or data.get('posterUrl'), # Fallback to posterUrl for backward compat
|
||||
backdrop=data.get('backdrop') or data.get('backdropUrl'), # Fallback to backdropUrl
|
||||
poster_path=data.get('posterPath'),
|
||||
backdrop_path=data.get('backdropPath'),
|
||||
description=description,
|
||||
genres=genres,
|
||||
episode_title=episode_title,
|
||||
rating=rating,
|
||||
release_date=release_date,
|
||||
tagline=tagline,
|
||||
studios=studios,
|
||||
)
|
||||
|
||||
def _parse_nested_array(self, data: dict, prefix: str) -> list:
|
||||
"""Parse nested array format (prefix/0, prefix/1, etc.) into a list."""
|
||||
items = []
|
||||
index = 0
|
||||
while True:
|
||||
key = f'{prefix}/{index}'
|
||||
if key in data:
|
||||
items.append(data[key])
|
||||
index += 1
|
||||
else:
|
||||
break
|
||||
return items
|
||||
|
||||
def get_all_videos(self) -> List[VideoMetadata]:
|
||||
"""Get all videos from Redis."""
|
||||
if not self.is_connected():
|
||||
return []
|
||||
|
||||
videos = []
|
||||
pattern = f"{self._prefix}file:*"
|
||||
|
||||
try:
|
||||
for key in self._client.scan_iter(pattern, count=100):
|
||||
# Skip special keys (like file:__index__ which is a set, not a hash)
|
||||
if '__index__' in key or not key.startswith(f"{self._prefix}file:"):
|
||||
continue
|
||||
|
||||
# Check key type - only process hash keys
|
||||
key_type = self._client.type(key)
|
||||
if key_type != 'hash':
|
||||
continue
|
||||
|
||||
# Check file type - only include video files
|
||||
file_type = self._client.hget(key, 'fileType')
|
||||
if file_type != 'video':
|
||||
continue
|
||||
|
||||
# Extract hash_id from key
|
||||
hash_id = key.replace(f"{self._prefix}file:", "")
|
||||
data = self._client.hgetall(key)
|
||||
video = self._parse_video(hash_id, data)
|
||||
if video and video.file_path:
|
||||
videos.append(video)
|
||||
except Exception as e:
|
||||
print(f"[RedisStorage] Error getting all videos: {e}")
|
||||
|
||||
# Sort by title
|
||||
videos.sort(key=lambda v: v.title.lower())
|
||||
return videos
|
||||
|
||||
def get_video_by_hash(self, hash_id: str) -> Optional[VideoMetadata]:
|
||||
"""Get a video by its hash ID."""
|
||||
if not self.is_connected():
|
||||
return None
|
||||
|
||||
try:
|
||||
key = self._get_file_key(hash_id)
|
||||
data = self._client.hgetall(key)
|
||||
return self._parse_video(hash_id, data)
|
||||
except Exception as e:
|
||||
print(f"[RedisStorage] Error getting video {hash_id}: {e}")
|
||||
return None
|
||||
|
||||
def get_videos_by_type(self, video_type: str) -> List[VideoMetadata]:
|
||||
"""Get all videos of a specific type."""
|
||||
videos = self.get_all_videos()
|
||||
return [v for v in videos if v.video_type == video_type]
|
||||
|
||||
def search_videos(self, query: str) -> List[VideoMetadata]:
|
||||
"""Search videos by title."""
|
||||
if not query:
|
||||
return self.get_all_videos()
|
||||
|
||||
query_lower = query.lower()
|
||||
videos = self.get_all_videos()
|
||||
return [v for v in videos if query_lower in v.title.lower()]
|
||||
|
||||
def get_video_by_imdb_id(self, imdb_id: str) -> Optional[VideoMetadata]:
|
||||
"""Get a video by its IMDB ID (e.g., 'tt1727587')."""
|
||||
if not self.is_connected() or not imdb_id:
|
||||
return None
|
||||
|
||||
# Normalize IMDB ID format
|
||||
imdb_id = imdb_id.lower()
|
||||
if not imdb_id.startswith('tt'):
|
||||
imdb_id = f"tt{imdb_id}"
|
||||
|
||||
try:
|
||||
# Scan all videos looking for matching IMDB ID
|
||||
pattern = f"{self._prefix}file:*"
|
||||
for key in self._client.scan_iter(pattern, count=100):
|
||||
# Check imdbid/imdbId field
|
||||
stored_imdb = self._client.hget(key, 'imdbid') or self._client.hget(key, 'imdbId')
|
||||
if stored_imdb and stored_imdb.lower() == imdb_id:
|
||||
hash_id = key.replace(f"{self._prefix}file:", "")
|
||||
data = self._client.hgetall(key)
|
||||
return self._parse_video(hash_id, data)
|
||||
|
||||
except Exception as e:
|
||||
print(f"[RedisStorage] Error finding video by IMDB ID {imdb_id}: {e}")
|
||||
|
||||
return None
|
||||
|
||||
def get_video_count(self) -> int:
|
||||
"""Get total number of videos."""
|
||||
if not self.is_connected():
|
||||
return 0
|
||||
|
||||
try:
|
||||
pattern = f"{self._prefix}file:*"
|
||||
count = 0
|
||||
for _ in self._client.scan_iter(pattern, count=100):
|
||||
count += 1
|
||||
return count
|
||||
except Exception as e:
|
||||
print(f"[RedisStorage] Error counting videos: {e}")
|
||||
return 0
|
||||
|
||||
def get_status(self) -> dict:
|
||||
"""Get storage status for dashboard."""
|
||||
status = {
|
||||
'type': 'redis',
|
||||
'connected': self.is_connected(),
|
||||
'url': self._url,
|
||||
'prefix': self._prefix,
|
||||
'video_count': 0,
|
||||
}
|
||||
|
||||
if status['connected']:
|
||||
try:
|
||||
status['video_count'] = self.get_video_count()
|
||||
info = self._client.info('memory')
|
||||
status['memory_used'] = info.get('used_memory_human', 'N/A')
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return status
|
||||
@@ -0,0 +1,367 @@
|
||||
"""
|
||||
Service Discovery for meta-stremio.
|
||||
|
||||
Python implementation of the service discovery pattern used in meta-sort.
|
||||
Each service registers itself in /meta-core/services/{service-name}.json
|
||||
and can discover other registered services.
|
||||
|
||||
Features:
|
||||
- Service registration with heartbeat
|
||||
- Discovery of all running services
|
||||
- Stale service detection (60 second threshold)
|
||||
- Automatic heartbeat loop
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import json
|
||||
import socket
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import dataclass, field, asdict
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import List, Optional, Dict, Callable
|
||||
from urllib.request import urlopen
|
||||
from urllib.error import URLError
|
||||
|
||||
|
||||
# Configuration
|
||||
META_CORE_PATH = os.environ.get('META_CORE_PATH', '/meta-core')
|
||||
SERVICE_NAME = os.environ.get('SERVICE_NAME', 'meta-stremio')
|
||||
SERVICE_VERSION = os.environ.get('SERVICE_VERSION', '1.0.0')
|
||||
BASE_URL = os.environ.get('BASE_URL', '')
|
||||
|
||||
|
||||
@dataclass
|
||||
class ServiceInfo:
|
||||
"""Service registration info stored in JSON file."""
|
||||
name: str
|
||||
version: str
|
||||
api: str # HTTP API URL (e.g., http://10.0.1.50:7000)
|
||||
status: str = 'starting' # starting | running | stopping | stopped
|
||||
pid: int = 0
|
||||
hostname: str = ''
|
||||
startedAt: str = ''
|
||||
lastHeartbeat: str = ''
|
||||
capabilities: List[str] = field(default_factory=list)
|
||||
endpoints: Dict[str, str] = field(default_factory=dict)
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
"""Convert to dictionary for JSON serialization."""
|
||||
return asdict(self)
|
||||
|
||||
|
||||
class ServiceDiscovery:
|
||||
"""
|
||||
Service Discovery using shared filesystem.
|
||||
|
||||
Each service registers itself in /meta-core/services/{service-name}.json
|
||||
and can discover other registered services.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
meta_core_path: str = None,
|
||||
service_name: str = None,
|
||||
version: str = None,
|
||||
api_url: str = None,
|
||||
base_url: str = None,
|
||||
capabilities: List[str] = None,
|
||||
endpoints: Dict[str, str] = None,
|
||||
heartbeat_interval: float = 30.0,
|
||||
stale_threshold: float = 60.0
|
||||
):
|
||||
self.meta_core_path = meta_core_path or META_CORE_PATH
|
||||
self.service_name = service_name or SERVICE_NAME
|
||||
self.version = version or SERVICE_VERSION
|
||||
# Use base_url if provided, then api_url, then env BASE_URL, then auto-detect
|
||||
self.api_url = base_url or api_url or BASE_URL or self._get_default_api_url()
|
||||
self.capabilities = capabilities or ['streaming', 'transcoding', 'hls']
|
||||
self.endpoints = endpoints or {
|
||||
'health': '/health',
|
||||
'manifest': '/manifest.json',
|
||||
'dashboard': '/',
|
||||
'api': '/api',
|
||||
}
|
||||
self.heartbeat_interval = heartbeat_interval
|
||||
self.stale_threshold = stale_threshold
|
||||
|
||||
self.services_dir = os.path.join(self.meta_core_path, 'services')
|
||||
self.service_file_path = os.path.join(self.services_dir, f'{self.service_name}.json')
|
||||
|
||||
self._heartbeat_thread: Optional[threading.Thread] = None
|
||||
self._stop_event = threading.Event()
|
||||
self._is_started = False
|
||||
|
||||
def _get_default_api_url(self) -> str:
|
||||
"""Get default API URL using local IP and PORT."""
|
||||
port = os.environ.get('PORT', '7000')
|
||||
ip = self._get_local_ip()
|
||||
return f'http://{ip}:{port}'
|
||||
|
||||
def _get_local_ip(self) -> str:
|
||||
"""Get the local machine's IP address."""
|
||||
try:
|
||||
# Create a socket to determine the outbound IP
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
s.connect(('8.8.8.8', 80))
|
||||
ip = s.getsockname()[0]
|
||||
s.close()
|
||||
return ip
|
||||
except Exception:
|
||||
return socket.gethostname() or 'localhost'
|
||||
|
||||
def _ensure_services_dir(self) -> None:
|
||||
"""Ensure services directory exists."""
|
||||
Path(self.services_dir).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
def _build_service_info(self, status: str = 'starting') -> ServiceInfo:
|
||||
"""Build service info for this service."""
|
||||
now = datetime.utcnow().isoformat() + 'Z'
|
||||
return ServiceInfo(
|
||||
name=self.service_name,
|
||||
version=self.version,
|
||||
api=self.api_url,
|
||||
status=status,
|
||||
pid=os.getpid(),
|
||||
hostname=socket.gethostname(),
|
||||
startedAt=now,
|
||||
lastHeartbeat=now,
|
||||
capabilities=self.capabilities,
|
||||
endpoints=self.endpoints
|
||||
)
|
||||
|
||||
def register(self) -> None:
|
||||
"""Register this service."""
|
||||
self._ensure_services_dir()
|
||||
|
||||
info = self._build_service_info('starting')
|
||||
|
||||
with open(self.service_file_path, 'w') as f:
|
||||
json.dump(info.to_dict(), f, indent=2)
|
||||
|
||||
print(f'[ServiceDiscovery] Registered {self.service_name}')
|
||||
|
||||
def update_status(self, status: str) -> None:
|
||||
"""Update service status."""
|
||||
try:
|
||||
with open(self.service_file_path, 'r') as f:
|
||||
info = json.load(f)
|
||||
|
||||
info['status'] = status
|
||||
info['lastHeartbeat'] = datetime.utcnow().isoformat() + 'Z'
|
||||
|
||||
with open(self.service_file_path, 'w') as f:
|
||||
json.dump(info, f, indent=2)
|
||||
|
||||
except Exception as e:
|
||||
print(f'[ServiceDiscovery] Failed to update status: {e}')
|
||||
|
||||
def heartbeat(self) -> None:
|
||||
"""Send heartbeat (update lastHeartbeat timestamp)."""
|
||||
try:
|
||||
with open(self.service_file_path, 'r') as f:
|
||||
info = json.load(f)
|
||||
|
||||
info['lastHeartbeat'] = datetime.utcnow().isoformat() + 'Z'
|
||||
|
||||
with open(self.service_file_path, 'w') as f:
|
||||
json.dump(info, f, indent=2)
|
||||
|
||||
except FileNotFoundError:
|
||||
# If file was deleted, re-register
|
||||
self.register()
|
||||
self.update_status('running')
|
||||
except Exception as e:
|
||||
print(f'[ServiceDiscovery] Heartbeat failed: {e}')
|
||||
|
||||
def _heartbeat_loop(self) -> None:
|
||||
"""Background heartbeat loop."""
|
||||
while not self._stop_event.is_set():
|
||||
try:
|
||||
self.heartbeat()
|
||||
except Exception as e:
|
||||
print(f'[ServiceDiscovery] Heartbeat error: {e}')
|
||||
|
||||
self._stop_event.wait(self.heartbeat_interval)
|
||||
|
||||
def start_heartbeat(self) -> None:
|
||||
"""Start heartbeat loop in background thread."""
|
||||
if self._heartbeat_thread and self._heartbeat_thread.is_alive():
|
||||
return
|
||||
|
||||
self._stop_event.clear()
|
||||
self._heartbeat_thread = threading.Thread(
|
||||
target=self._heartbeat_loop,
|
||||
daemon=True,
|
||||
name='service-heartbeat'
|
||||
)
|
||||
self._heartbeat_thread.start()
|
||||
|
||||
def stop_heartbeat(self) -> None:
|
||||
"""Stop heartbeat loop."""
|
||||
self._stop_event.set()
|
||||
if self._heartbeat_thread and self._heartbeat_thread.is_alive():
|
||||
self._heartbeat_thread.join(timeout=2.0)
|
||||
|
||||
def unregister(self) -> None:
|
||||
"""Unregister this service (on shutdown)."""
|
||||
self.stop_heartbeat()
|
||||
|
||||
try:
|
||||
self.update_status('stopped')
|
||||
print(f'[ServiceDiscovery] Unregistered {self.service_name}')
|
||||
except Exception as e:
|
||||
print(f'[ServiceDiscovery] Failed to unregister: {e}')
|
||||
|
||||
# ========================================================================
|
||||
# Discovery Methods
|
||||
# ========================================================================
|
||||
|
||||
def _is_service_stale(self, info: dict) -> bool:
|
||||
"""Check if a service is stale based on lastHeartbeat."""
|
||||
try:
|
||||
last_heartbeat_str = info.get('lastHeartbeat', '')
|
||||
if not last_heartbeat_str:
|
||||
return True
|
||||
|
||||
# Parse ISO timestamp
|
||||
last_heartbeat_str = last_heartbeat_str.rstrip('Z')
|
||||
last_heartbeat = datetime.fromisoformat(last_heartbeat_str)
|
||||
age = (datetime.utcnow() - last_heartbeat).total_seconds()
|
||||
|
||||
return age > self.stale_threshold
|
||||
except Exception:
|
||||
return True
|
||||
|
||||
def discover_service(self, name: str) -> Optional[dict]:
|
||||
"""Discover a service by name."""
|
||||
service_path = os.path.join(self.services_dir, f'{name}.json')
|
||||
|
||||
try:
|
||||
with open(service_path, 'r') as f:
|
||||
info = json.load(f)
|
||||
|
||||
# Check if service is alive
|
||||
if self._is_service_stale(info):
|
||||
print(f'[ServiceDiscovery] Service {name} appears stale')
|
||||
return None
|
||||
|
||||
return info
|
||||
|
||||
except FileNotFoundError:
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f'[ServiceDiscovery] Error discovering {name}: {e}')
|
||||
return None
|
||||
|
||||
def discover_all_services(self) -> List[dict]:
|
||||
"""Discover all registered services."""
|
||||
services = []
|
||||
|
||||
try:
|
||||
if not os.path.exists(self.services_dir):
|
||||
return services
|
||||
|
||||
for filename in os.listdir(self.services_dir):
|
||||
if not filename.endswith('.json'):
|
||||
continue
|
||||
|
||||
name = filename.replace('.json', '')
|
||||
service = self.discover_service(name)
|
||||
|
||||
if service and service.get('status') == 'running':
|
||||
services.append(service)
|
||||
|
||||
except Exception as e:
|
||||
print(f'[ServiceDiscovery] Error discovering services: {e}')
|
||||
|
||||
return services
|
||||
|
||||
def is_service_healthy(self, name: str) -> bool:
|
||||
"""Check if a service is healthy via HTTP ping."""
|
||||
service = self.discover_service(name)
|
||||
if not service:
|
||||
return False
|
||||
|
||||
health_endpoint = service.get('endpoints', {}).get('health', '/health')
|
||||
url = f"{service['api']}{health_endpoint}"
|
||||
|
||||
try:
|
||||
with urlopen(url, timeout=5) as response:
|
||||
return response.status == 200
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
# ========================================================================
|
||||
# Lifecycle
|
||||
# ========================================================================
|
||||
|
||||
def start(self) -> None:
|
||||
"""Full startup sequence."""
|
||||
if self._is_started:
|
||||
return
|
||||
|
||||
# Try to register, but don't fail if filesystem is read-only
|
||||
# This allows discovery-only mode when we can't write
|
||||
can_register = os.access(self.services_dir, os.W_OK) if os.path.exists(self.services_dir) else False
|
||||
|
||||
if can_register:
|
||||
try:
|
||||
self.register()
|
||||
self.update_status('running')
|
||||
self.start_heartbeat()
|
||||
print(f'[ServiceDiscovery] Started {self.service_name} at {self.api_url}')
|
||||
except Exception as e:
|
||||
print(f'[ServiceDiscovery] Registration failed (read-only?): {e}')
|
||||
print(f'[ServiceDiscovery] Running in discovery-only mode')
|
||||
else:
|
||||
print(f'[ServiceDiscovery] Services directory not writable, running in discovery-only mode')
|
||||
|
||||
self._is_started = True
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Full shutdown sequence."""
|
||||
if not self._is_started:
|
||||
return
|
||||
|
||||
self.unregister()
|
||||
self._is_started = False
|
||||
|
||||
# ========================================================================
|
||||
# Getters
|
||||
# ========================================================================
|
||||
|
||||
def get_service_file_path(self) -> str:
|
||||
return self.service_file_path
|
||||
|
||||
def get_services_dir(self) -> str:
|
||||
return self.services_dir
|
||||
|
||||
def is_started(self) -> bool:
|
||||
return self._is_started
|
||||
|
||||
|
||||
# Singleton instance
|
||||
_service_discovery: Optional[ServiceDiscovery] = None
|
||||
|
||||
|
||||
def get_service_discovery() -> ServiceDiscovery:
|
||||
"""Get or create the service discovery singleton."""
|
||||
global _service_discovery
|
||||
if _service_discovery is None:
|
||||
_service_discovery = ServiceDiscovery()
|
||||
return _service_discovery
|
||||
|
||||
|
||||
def init_service_discovery(
|
||||
api_url: str = None,
|
||||
base_url: str = None,
|
||||
**kwargs
|
||||
) -> ServiceDiscovery:
|
||||
"""Initialize and start the service discovery singleton."""
|
||||
global _service_discovery
|
||||
_service_discovery = ServiceDiscovery(api_url=api_url, base_url=base_url, **kwargs)
|
||||
_service_discovery.start()
|
||||
return _service_discovery
|
||||
+1204
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,863 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
HLS Live Transcoder Engine
|
||||
|
||||
Transcodes video segments on-demand using FFmpeg with adaptive quality.
|
||||
|
||||
Design: Single-threaded transcoding with multi-ahead prefetch.
|
||||
- One FFmpeg process gets 100% CPU for fastest segment time
|
||||
- After serving segment N, prefetch N+1..N+4 in background
|
||||
- No parallel transcoding (would split CPU and increase latency)
|
||||
|
||||
Adapted from SegmentPlayer's transcoder for standalone Stremio addon use.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
import hashlib
|
||||
import threading
|
||||
import time
|
||||
import json
|
||||
import re
|
||||
from typing import Optional
|
||||
|
||||
# Configuration
|
||||
MEDIA_DIR = os.environ.get('MEDIA_DIR', '/data/media')
|
||||
CACHE_DIR = os.environ.get('CACHE_DIR', '/data/cache')
|
||||
SEGMENT_DURATION = int(os.environ.get('SEGMENT_DURATION', '4'))
|
||||
PREFETCH_SEGMENTS = int(os.environ.get('PREFETCH_SEGMENTS', '4'))
|
||||
|
||||
os.makedirs(CACHE_DIR, exist_ok=True)
|
||||
|
||||
# Resolution presets: (width, height, crf)
|
||||
RESOLUTIONS = {
|
||||
'original': (None, None, 23),
|
||||
'1080p': (1920, 1080, 23),
|
||||
'720p': (1280, 720, 24),
|
||||
'480p': (854, 480, 25),
|
||||
'360p': (640, 360, 26),
|
||||
}
|
||||
|
||||
# x264 presets ordered from fastest to slowest
|
||||
X264_PRESETS = ['ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow']
|
||||
|
||||
# Subtitle codecs that cannot be converted to WebVTT (image-based)
|
||||
UNSUPPORTED_SUBTITLE_CODECS = {'hdmv_pgs_subtitle', 'dvd_subtitle', 'dvb_subtitle', 'xsub'}
|
||||
|
||||
|
||||
class AdaptiveQuality:
|
||||
"""
|
||||
Coordinated adaptive quality control using both preset and CRF.
|
||||
|
||||
Strategy - PRIORITIZE LOW CRF (quality over compression efficiency):
|
||||
- CRF directly affects output quality (lower = better visual quality)
|
||||
- Preset affects encoding speed (faster = less CPU, slightly worse compression)
|
||||
- For streaming, visual quality matters more than file size
|
||||
- So: keep CRF low, use faster presets when needed
|
||||
|
||||
Target: 60-80% of segment duration (transcode ratio)
|
||||
- Below 60%: We have headroom, can increase quality
|
||||
- 60-80%: Sweet spot, maintain current settings
|
||||
- Above 80%: Too slow, decrease quality (preset first!)
|
||||
- Above 100%: EMERGENCY, drop to fastest settings
|
||||
|
||||
Coordination rules:
|
||||
- DECREASE quality: Drop preset first (faster encoding), CRF only as last resort
|
||||
- INCREASE quality: Decrease CRF first (better quality), then preset (capped at 'medium')
|
||||
- Max preset is 'medium' - slower presets waste CPU for minimal streaming benefit
|
||||
"""
|
||||
|
||||
MAX_PRESET_INDEX = 5 # 'medium' - slower presets not worth it for streaming
|
||||
|
||||
def __init__(self, initial_preset: str = 'fast'):
|
||||
self._lock = threading.Lock()
|
||||
|
||||
# Preset state (capped at medium)
|
||||
initial_index = X264_PRESETS.index(initial_preset) if initial_preset in X264_PRESETS else 4
|
||||
self._preset_index = min(initial_index, self.MAX_PRESET_INDEX)
|
||||
|
||||
# CRF state
|
||||
self._crf_offset = 0 # 0 to 7
|
||||
|
||||
# Shared state
|
||||
self._recent_ratios: list[float] = []
|
||||
self._window_size = 5
|
||||
self._consecutive_good_signals = 0
|
||||
self._last_change_time = 0.0
|
||||
|
||||
# Thresholds
|
||||
self._target_min = 60.0
|
||||
self._target_max = 80.0
|
||||
|
||||
# Stats
|
||||
self._preset_ups = 0
|
||||
self._preset_downs = 0
|
||||
self._crf_ups = 0
|
||||
self._crf_downs = 0
|
||||
|
||||
@property
|
||||
def preset(self) -> str:
|
||||
with self._lock:
|
||||
return X264_PRESETS[self._preset_index]
|
||||
|
||||
def get_crf(self, base_crf: int) -> int:
|
||||
with self._lock:
|
||||
return min(base_crf + self._crf_offset, 30)
|
||||
|
||||
def record_transcode(self, elapsed: float) -> dict | None:
|
||||
"""Record transcode time and adjust quality settings."""
|
||||
last_ratio = (elapsed / SEGMENT_DURATION) * 100
|
||||
|
||||
with self._lock:
|
||||
self._recent_ratios.append(last_ratio)
|
||||
if len(self._recent_ratios) > self._window_size:
|
||||
self._recent_ratios.pop(0)
|
||||
|
||||
avg_ratio = sum(self._recent_ratios) / len(self._recent_ratios)
|
||||
current_time = time.time()
|
||||
|
||||
old_preset = X264_PRESETS[self._preset_index]
|
||||
old_crf = self._crf_offset
|
||||
|
||||
# EMERGENCY: ratio > 100%
|
||||
if last_ratio > 100:
|
||||
if self._preset_index > 0 or self._crf_offset < 7:
|
||||
self._preset_index = 0 # ultrafast
|
||||
self._crf_offset = 7
|
||||
self._consecutive_good_signals = 0
|
||||
self._last_change_time = current_time
|
||||
self._recent_ratios.clear()
|
||||
self._preset_downs += 1
|
||||
self._crf_ups += 1
|
||||
print(f"[AdaptiveQuality] EMERGENCY {last_ratio:.1f}% → ultrafast, CRF +7")
|
||||
return {'preset': 'ultrafast', 'crf_offset': 7, 'emergency': True}
|
||||
|
||||
# DECREASE QUALITY: last ratio > 80%
|
||||
if last_ratio > self._target_max:
|
||||
self._consecutive_good_signals = 0
|
||||
|
||||
if self._preset_index > 0:
|
||||
self._preset_index -= 1
|
||||
self._preset_downs += 1
|
||||
self._last_change_time = current_time
|
||||
new_preset = X264_PRESETS[self._preset_index]
|
||||
print(f"[AdaptiveQuality] Last {last_ratio:.1f}% > {self._target_max}% → {old_preset} → {new_preset}")
|
||||
return {'preset': new_preset}
|
||||
elif self._crf_offset < 7:
|
||||
self._crf_offset = min(self._crf_offset + 2, 7)
|
||||
self._crf_ups += 1
|
||||
self._last_change_time = current_time
|
||||
print(f"[AdaptiveQuality] Last {last_ratio:.1f}% > {self._target_max}% (ultrafast) → CRF +{old_crf} → +{self._crf_offset}")
|
||||
return {'crf_offset': self._crf_offset}
|
||||
|
||||
# INCREASE QUALITY: avg ratio < 60%
|
||||
elif avg_ratio < self._target_min:
|
||||
self._consecutive_good_signals += 1
|
||||
|
||||
if self._consecutive_good_signals >= 3 and current_time - self._last_change_time >= 5.0:
|
||||
if self._crf_offset > 0:
|
||||
self._crf_offset -= 1
|
||||
self._crf_downs += 1
|
||||
self._consecutive_good_signals = 0
|
||||
self._last_change_time = current_time
|
||||
print(f"[AdaptiveQuality] Avg {avg_ratio:.1f}% < {self._target_min}% → CRF +{old_crf} → +{self._crf_offset}")
|
||||
return {'crf_offset': self._crf_offset}
|
||||
elif self._preset_index < self.MAX_PRESET_INDEX:
|
||||
self._preset_index += 1
|
||||
self._preset_ups += 1
|
||||
self._consecutive_good_signals = 0
|
||||
self._last_change_time = current_time
|
||||
new_preset = X264_PRESETS[self._preset_index]
|
||||
print(f"[AdaptiveQuality] Avg {avg_ratio:.1f}% < {self._target_min}% → {old_preset} → {new_preset}")
|
||||
return {'preset': new_preset}
|
||||
else:
|
||||
self._consecutive_good_signals = 0
|
||||
|
||||
return None
|
||||
|
||||
def get_stats(self) -> dict:
|
||||
with self._lock:
|
||||
avg_ratio = sum(self._recent_ratios) / len(self._recent_ratios) if self._recent_ratios else 0
|
||||
last_ratio = self._recent_ratios[-1] if self._recent_ratios else 0
|
||||
return {
|
||||
'preset': X264_PRESETS[self._preset_index],
|
||||
'crf_offset': self._crf_offset,
|
||||
'target_range': f"{self._target_min:.0f}-{self._target_max:.0f}%",
|
||||
'avg_ratio': round(avg_ratio, 1),
|
||||
'last_ratio': round(last_ratio, 1),
|
||||
'preset_adjustments': {'up': self._preset_ups, 'down': self._preset_downs},
|
||||
'crf_adjustments': {'up': self._crf_ups, 'down': self._crf_downs},
|
||||
}
|
||||
|
||||
|
||||
class SegmentManager:
|
||||
"""
|
||||
Manages segment transcoding with single-threaded execution.
|
||||
|
||||
Design rationale:
|
||||
- Single FFmpeg gets 100% CPU → fastest per-segment time
|
||||
- Multi-ahead prefetch uses idle time while user watches current segment
|
||||
- Multiple requests for same segment wait on shared Event
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self._lock = threading.Lock()
|
||||
self._in_progress: dict[str, threading.Event] = {}
|
||||
self._prefetch_thread: threading.Thread | None = None
|
||||
self._prefetch_queue: list[tuple[str, callable]] = []
|
||||
|
||||
# Metrics
|
||||
self.total_segments = 0
|
||||
self.cache_hits = 0
|
||||
self.total_transcode_time = 0.0
|
||||
self.last_segment_time = 0.0
|
||||
self.min_segment_time = float('inf')
|
||||
self.max_segment_time = 0.0
|
||||
self._transcode_times: list[float] = []
|
||||
|
||||
# Current file codec info
|
||||
self.current_video_codec: str | None = None
|
||||
self.current_audio_codec: str | None = None
|
||||
self.current_file: str | None = None
|
||||
|
||||
def get_segment(self, key: str, transcode_fn) -> str | None:
|
||||
"""Get a segment, transcoding if necessary."""
|
||||
with self._lock:
|
||||
self.total_segments += 1
|
||||
|
||||
if key in self._in_progress:
|
||||
event = self._in_progress[key]
|
||||
wait_for_other = True
|
||||
else:
|
||||
event = threading.Event()
|
||||
self._in_progress[key] = event
|
||||
wait_for_other = False
|
||||
|
||||
if wait_for_other:
|
||||
completed = event.wait(timeout=120)
|
||||
if completed:
|
||||
return transcode_fn()
|
||||
else:
|
||||
return None
|
||||
|
||||
try:
|
||||
result = transcode_fn()
|
||||
return result
|
||||
finally:
|
||||
with self._lock:
|
||||
self._in_progress.pop(key, None)
|
||||
event.set()
|
||||
|
||||
def schedule_prefetch(self, key: str, transcode_fn):
|
||||
"""Schedule prefetch for a segment."""
|
||||
with self._lock:
|
||||
if key in self._in_progress:
|
||||
return
|
||||
if any(k == key for k, _ in self._prefetch_queue):
|
||||
return
|
||||
|
||||
self._prefetch_queue.append((key, transcode_fn))
|
||||
|
||||
if not self._prefetch_thread or not self._prefetch_thread.is_alive():
|
||||
self._prefetch_thread = threading.Thread(
|
||||
target=self._process_prefetch_queue,
|
||||
daemon=True
|
||||
)
|
||||
self._prefetch_thread.start()
|
||||
|
||||
def _process_prefetch_queue(self):
|
||||
"""Process prefetch queue sequentially."""
|
||||
while True:
|
||||
with self._lock:
|
||||
if not self._prefetch_queue:
|
||||
return
|
||||
|
||||
key, transcode_fn = self._prefetch_queue.pop(0)
|
||||
if key in self._in_progress:
|
||||
continue
|
||||
|
||||
event = threading.Event()
|
||||
self._in_progress[key] = event
|
||||
|
||||
try:
|
||||
transcode_fn()
|
||||
finally:
|
||||
with self._lock:
|
||||
self._in_progress.pop(key, None)
|
||||
event.set()
|
||||
|
||||
def is_in_progress(self, key: str) -> bool:
|
||||
with self._lock:
|
||||
return key in self._in_progress
|
||||
|
||||
def record_cache_hit(self):
|
||||
with self._lock:
|
||||
self.total_segments += 1
|
||||
self.cache_hits += 1
|
||||
|
||||
def record_transcode_time(self, elapsed: float):
|
||||
with self._lock:
|
||||
self.total_transcode_time += elapsed
|
||||
self.last_segment_time = elapsed
|
||||
if elapsed < self.min_segment_time:
|
||||
self.min_segment_time = elapsed
|
||||
if elapsed > self.max_segment_time:
|
||||
self.max_segment_time = elapsed
|
||||
self._transcode_times.append(elapsed)
|
||||
if len(self._transcode_times) > 100:
|
||||
self._transcode_times.pop(0)
|
||||
|
||||
def set_codec_info(self, video_codec: str | None, audio_codec: str | None, filepath: str | None = None):
|
||||
with self._lock:
|
||||
self.current_video_codec = video_codec
|
||||
self.current_audio_codec = audio_codec
|
||||
if filepath:
|
||||
self.current_file = filepath
|
||||
|
||||
def get_metrics(self) -> dict:
|
||||
with self._lock:
|
||||
avg_time = sum(self._transcode_times) / len(self._transcode_times) if self._transcode_times else 0
|
||||
last_ratio = (self.last_segment_time / SEGMENT_DURATION * 100) if self.last_segment_time > 0 else 0
|
||||
avg_ratio = (avg_time / SEGMENT_DURATION * 100) if avg_time > 0 else 0
|
||||
return {
|
||||
'total_segments': self.total_segments,
|
||||
'cache_hits': self.cache_hits,
|
||||
'cache_hit_rate': round((self.cache_hits / self.total_segments * 100), 1) if self.total_segments > 0 else 0,
|
||||
'prefetch_queue_size': len(self._prefetch_queue),
|
||||
'total_transcode_time': round(self.total_transcode_time, 2),
|
||||
'last_segment_time': round(self.last_segment_time, 2),
|
||||
'avg_segment_time': round(avg_time, 2),
|
||||
'segment_duration': SEGMENT_DURATION,
|
||||
'transcode_ratio_last': round(last_ratio, 1),
|
||||
'transcode_ratio_avg': round(avg_ratio, 1),
|
||||
'video_codec': self.current_video_codec,
|
||||
'audio_codec': self.current_audio_codec,
|
||||
'current_file': self.current_file,
|
||||
}
|
||||
|
||||
def reset_metrics(self):
|
||||
with self._lock:
|
||||
self.total_segments = 0
|
||||
self.cache_hits = 0
|
||||
self.total_transcode_time = 0.0
|
||||
self.last_segment_time = 0.0
|
||||
self.min_segment_time = float('inf')
|
||||
self.max_segment_time = 0.0
|
||||
self._transcode_times.clear()
|
||||
|
||||
|
||||
class SubtitleManager:
|
||||
"""Manages subtitle extraction with background processing."""
|
||||
|
||||
def __init__(self):
|
||||
self._lock = threading.Lock()
|
||||
self._extractions: dict[str, tuple[threading.Event, list]] = {}
|
||||
|
||||
def get_subtitle(self, key: str, filepath: str, file_hash: str, sub_index: int,
|
||||
info: dict = None, timeout: float = 300) -> tuple[str | None, str | None]:
|
||||
"""Get subtitle content, extracting if necessary."""
|
||||
cache_dir = os.path.join(CACHE_DIR, file_hash)
|
||||
vtt_file = os.path.join(cache_dir, f"subtitle_{sub_index}.vtt")
|
||||
error_file = os.path.join(cache_dir, f"subtitle_{sub_index}.error")
|
||||
|
||||
# Fast path: already cached
|
||||
if os.path.exists(vtt_file):
|
||||
with open(vtt_file, 'r', encoding='utf-8') as f:
|
||||
return f.read(), None
|
||||
if os.path.exists(error_file):
|
||||
with open(error_file, 'r', encoding='utf-8') as f:
|
||||
return None, f.read()
|
||||
|
||||
with self._lock:
|
||||
if os.path.exists(vtt_file):
|
||||
with open(vtt_file, 'r', encoding='utf-8') as f:
|
||||
return f.read(), None
|
||||
if os.path.exists(error_file):
|
||||
with open(error_file, 'r', encoding='utf-8') as f:
|
||||
return None, f.read()
|
||||
|
||||
if key in self._extractions:
|
||||
event, result_holder = self._extractions[key]
|
||||
else:
|
||||
event = threading.Event()
|
||||
result_holder = [None]
|
||||
self._extractions[key] = (event, result_holder)
|
||||
|
||||
thread = threading.Thread(
|
||||
target=self._extract_background,
|
||||
args=(key, filepath, file_hash, sub_index, info, event, result_holder),
|
||||
daemon=True
|
||||
)
|
||||
thread.start()
|
||||
|
||||
completed = event.wait(timeout=timeout)
|
||||
|
||||
if completed:
|
||||
if result_holder[0] is not None:
|
||||
return result_holder[0]
|
||||
if os.path.exists(vtt_file):
|
||||
with open(vtt_file, 'r', encoding='utf-8') as f:
|
||||
return f.read(), None
|
||||
if os.path.exists(error_file):
|
||||
with open(error_file, 'r', encoding='utf-8') as f:
|
||||
return None, f.read()
|
||||
return None, "Extraction completed but result not found"
|
||||
|
||||
return None, f"Extraction timed out after {timeout}s"
|
||||
|
||||
def _extract_background(self, key: str, filepath: str, file_hash: str, sub_index: int,
|
||||
info: dict, event: threading.Event, result_holder: list):
|
||||
try:
|
||||
result = self._do_extract(filepath, file_hash, sub_index, info)
|
||||
result_holder[0] = result
|
||||
except Exception as e:
|
||||
result_holder[0] = (None, f"Extraction thread error: {e}")
|
||||
finally:
|
||||
event.set()
|
||||
def cleanup():
|
||||
time.sleep(30)
|
||||
with self._lock:
|
||||
self._extractions.pop(key, None)
|
||||
threading.Thread(target=cleanup, daemon=True).start()
|
||||
|
||||
def _do_extract(self, filepath: str, file_hash: str, sub_index: int,
|
||||
info: dict = None) -> tuple[str | None, str | None]:
|
||||
cache_dir = os.path.join(CACHE_DIR, file_hash)
|
||||
os.makedirs(cache_dir, exist_ok=True)
|
||||
|
||||
vtt_file = os.path.join(cache_dir, f"subtitle_{sub_index}.vtt")
|
||||
temp_file = vtt_file + '.tmp'
|
||||
error_file = os.path.join(cache_dir, f"subtitle_{sub_index}.error")
|
||||
|
||||
if os.path.exists(vtt_file):
|
||||
with open(vtt_file, 'r', encoding='utf-8') as f:
|
||||
return f.read(), None
|
||||
if os.path.exists(error_file):
|
||||
with open(error_file, 'r', encoding='utf-8') as f:
|
||||
return None, f.read()
|
||||
|
||||
# Get subtitle stream info
|
||||
codec = None
|
||||
track_index = None
|
||||
if info:
|
||||
subtitle_streams = [s for s in info.get('streams', []) if s.get('codec_type') == 'subtitle']
|
||||
if sub_index < len(subtitle_streams):
|
||||
stream = subtitle_streams[sub_index]
|
||||
codec = stream.get('codec_name', '')
|
||||
track_index = stream.get('index')
|
||||
if codec in UNSUPPORTED_SUBTITLE_CODECS:
|
||||
error_msg = f"Subtitle format '{codec}' is image-based and cannot be converted to WebVTT"
|
||||
with open(error_file, 'w', encoding='utf-8') as f:
|
||||
f.write(error_msg)
|
||||
return None, error_msg
|
||||
|
||||
try:
|
||||
print(f"[Subtitle {sub_index}] Extracting from {os.path.basename(filepath)}...")
|
||||
is_mkv = filepath.lower().endswith(('.mkv', '.mka', '.mks'))
|
||||
|
||||
# Determine intermediate format based on codec
|
||||
codec_ext_map = {
|
||||
'subrip': 'srt', 'srt': 'srt',
|
||||
'ass': 'ass', 'ssa': 'ssa',
|
||||
'webvtt': 'vtt', 'mov_text': 'srt'
|
||||
}
|
||||
intermediate_ext = codec_ext_map.get(codec, 'srt') if codec else 'srt'
|
||||
intermediate_file = os.path.join(cache_dir, f"subtitle_{sub_index}.{intermediate_ext}")
|
||||
|
||||
extracted = False
|
||||
|
||||
# Method 1: Try mkvextract for MKV files (fastest)
|
||||
if is_mkv and track_index is not None:
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['mkvextract', 'tracks', filepath, f'{track_index}:{intermediate_file}'],
|
||||
capture_output=True,
|
||||
timeout=120
|
||||
)
|
||||
if result.returncode == 0 and os.path.exists(intermediate_file):
|
||||
extracted = True
|
||||
print(f"[Subtitle {sub_index}] Extracted via mkvextract")
|
||||
except FileNotFoundError:
|
||||
pass # mkvextract not installed, fall back to ffmpeg
|
||||
except Exception as e:
|
||||
print(f"[Subtitle {sub_index}] mkvextract failed: {e}, trying ffmpeg")
|
||||
|
||||
# Method 2: FFmpeg copy codec (fast demux, no re-encoding)
|
||||
if not extracted:
|
||||
result = subprocess.run(
|
||||
['ffmpeg', '-y', '-hide_banner', '-loglevel', 'error',
|
||||
'-probesize', '1M', '-analyzeduration', '1M',
|
||||
'-i', filepath,
|
||||
'-map', f'0:s:{sub_index}',
|
||||
'-c:s', 'copy', intermediate_file],
|
||||
capture_output=True,
|
||||
timeout=300
|
||||
)
|
||||
if result.returncode == 0 and os.path.exists(intermediate_file):
|
||||
extracted = True
|
||||
print(f"[Subtitle {sub_index}] Extracted via ffmpeg copy")
|
||||
|
||||
# Convert to WebVTT if needed
|
||||
if extracted and os.path.exists(intermediate_file):
|
||||
if intermediate_ext == 'vtt':
|
||||
# Already VTT, just rename
|
||||
os.rename(intermediate_file, temp_file)
|
||||
else:
|
||||
# Convert to WebVTT
|
||||
result = subprocess.run(
|
||||
['ffmpeg', '-y', '-hide_banner', '-loglevel', 'error',
|
||||
'-i', intermediate_file,
|
||||
'-c:s', 'webvtt', '-f', 'webvtt', temp_file],
|
||||
capture_output=True,
|
||||
timeout=60
|
||||
)
|
||||
# Clean up intermediate file
|
||||
if os.path.exists(intermediate_file):
|
||||
os.remove(intermediate_file)
|
||||
|
||||
if result.returncode != 0:
|
||||
stderr = result.stderr.decode('utf-8', errors='replace') if result.stderr else 'Unknown error'
|
||||
error_msg = f"VTT conversion failed: {stderr[:200]}"
|
||||
with open(error_file, 'w', encoding='utf-8') as f:
|
||||
f.write(error_msg)
|
||||
return None, error_msg
|
||||
|
||||
# Validate and finalize
|
||||
if os.path.exists(temp_file):
|
||||
file_size = os.path.getsize(temp_file)
|
||||
if file_size > 10:
|
||||
os.rename(temp_file, vtt_file)
|
||||
print(f"[Subtitle {sub_index}] Extraction complete ({file_size} bytes)")
|
||||
with open(vtt_file, 'r', encoding='utf-8') as f:
|
||||
return f.read(), None
|
||||
else:
|
||||
error_msg = "Extraction produced empty VTT file"
|
||||
os.remove(temp_file)
|
||||
else:
|
||||
error_msg = "Extraction failed - no output file"
|
||||
|
||||
with open(error_file, 'w', encoding='utf-8') as f:
|
||||
f.write(error_msg)
|
||||
return None, error_msg
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
error_msg = "Extraction timed out"
|
||||
with open(error_file, 'w', encoding='utf-8') as f:
|
||||
f.write(error_msg)
|
||||
return None, error_msg
|
||||
except Exception as e:
|
||||
error_msg = f"Unexpected error: {str(e)}"
|
||||
with open(error_file, 'w', encoding='utf-8') as f:
|
||||
f.write(error_msg)
|
||||
return None, error_msg
|
||||
|
||||
|
||||
# Global managers
|
||||
adaptive_quality = AdaptiveQuality(initial_preset='fast')
|
||||
segment_manager = SegmentManager()
|
||||
subtitle_manager = SubtitleManager()
|
||||
|
||||
|
||||
def get_file_hash(filepath: str) -> str:
|
||||
"""Generate cache key from filepath."""
|
||||
return hashlib.md5(filepath.encode()).hexdigest()[:16]
|
||||
|
||||
|
||||
def get_video_info(filepath: str) -> dict | None:
|
||||
"""Get video metadata using ffprobe."""
|
||||
full_path = os.path.join(MEDIA_DIR, filepath) if not filepath.startswith('/') else filepath
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['ffprobe', '-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', full_path],
|
||||
capture_output=True, text=True, timeout=30
|
||||
)
|
||||
return json.loads(result.stdout) if result.returncode == 0 else None
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def extract_codecs(info: dict) -> tuple[str | None, str | None]:
|
||||
"""Extract video and audio codec names from ffprobe info."""
|
||||
streams = info.get('streams', [])
|
||||
video_codec = None
|
||||
audio_codec = None
|
||||
|
||||
for stream in streams:
|
||||
codec_type = stream.get('codec_type')
|
||||
if codec_type == 'video' and video_codec is None:
|
||||
video_codec = stream.get('codec_name')
|
||||
elif codec_type == 'audio' and audio_codec is None:
|
||||
audio_codec = stream.get('codec_name')
|
||||
|
||||
return video_codec, audio_codec
|
||||
|
||||
|
||||
def get_segment_path(file_hash: str, audio: int, resolution: str, segment: int) -> str:
|
||||
"""Get cache path for a muxed video+audio segment."""
|
||||
return os.path.join(CACHE_DIR, file_hash, f"seg_a{audio}_{resolution}_{segment:05d}.ts")
|
||||
|
||||
|
||||
def transcode_segment(filepath: str, file_hash: str, audio: int, resolution: str, segment: int) -> str | None:
|
||||
"""
|
||||
Transcode a single segment using FFmpeg.
|
||||
|
||||
Optimized for speed with adaptive quality:
|
||||
- adaptive preset: auto-adjusts based on transcode ratio (target 60-80%)
|
||||
- threads 0: use all CPU cores
|
||||
- tune zerolatency: reduce encoding latency
|
||||
- Muxed video+audio: single segment contains both streams
|
||||
"""
|
||||
cache_dir = os.path.join(CACHE_DIR, file_hash)
|
||||
os.makedirs(cache_dir, exist_ok=True)
|
||||
|
||||
output = get_segment_path(file_hash, audio, resolution, segment)
|
||||
|
||||
# Already cached?
|
||||
if os.path.exists(output):
|
||||
return output
|
||||
|
||||
full_path = os.path.join(MEDIA_DIR, filepath) if not filepath.startswith('/') else filepath
|
||||
start_offset = segment * SEGMENT_DURATION
|
||||
res_preset = RESOLUTIONS.get(resolution, RESOLUTIONS['original'])
|
||||
width, height, base_crf = res_preset
|
||||
|
||||
# Get current adaptive preset and CRF
|
||||
current_preset = adaptive_quality.preset
|
||||
current_crf = adaptive_quality.get_crf(base_crf)
|
||||
|
||||
cpu_count = os.cpu_count() or 8
|
||||
|
||||
cmd = [
|
||||
'ffmpeg', '-y', '-hide_banner', '-loglevel', 'error',
|
||||
'-threads', str(cpu_count),
|
||||
'-ss', str(start_offset),
|
||||
'-i', full_path,
|
||||
'-t', str(SEGMENT_DURATION),
|
||||
'-map', '0:v:0',
|
||||
'-map', f'0:a:{audio}?', # ? = optional, don't fail if audio track doesn't exist
|
||||
# Video: H.264 with adaptive quality
|
||||
'-c:v', 'libx264',
|
||||
'-preset', current_preset,
|
||||
'-tune', 'zerolatency',
|
||||
'-crf', str(current_crf),
|
||||
'-pix_fmt', 'yuv420p',
|
||||
'-x264-params', f'threads={cpu_count}:lookahead_threads={min(cpu_count, 8)}',
|
||||
'-force_key_frames', 'expr:gte(t,0)',
|
||||
# Audio: AAC (muxed with video)
|
||||
'-c:a', 'aac', '-b:a', '128k', '-ac', '2',
|
||||
# Output format
|
||||
'-f', 'mpegts',
|
||||
'-mpegts_copyts', '1',
|
||||
'-output_ts_offset', str(start_offset),
|
||||
]
|
||||
|
||||
if width and height:
|
||||
cmd.extend(['-vf', f'scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2'])
|
||||
|
||||
cmd.append(output)
|
||||
|
||||
start_time = time.time()
|
||||
try:
|
||||
result = subprocess.run(cmd, capture_output=True, timeout=120)
|
||||
elapsed = time.time() - start_time
|
||||
if result.returncode == 0 and os.path.exists(output):
|
||||
segment_manager.record_transcode_time(elapsed)
|
||||
adaptive_quality.record_transcode(elapsed)
|
||||
return output
|
||||
print(f"FFmpeg error: {result.stderr.decode()[-500:]}")
|
||||
except Exception as e:
|
||||
print(f"Transcode error: {e}")
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def get_or_transcode_segment(filepath: str, file_hash: str, audio: int, resolution: str,
|
||||
segment: int, info: dict) -> bytes | None:
|
||||
"""Get segment data, transcoding if necessary."""
|
||||
output = get_segment_path(file_hash, audio, resolution, segment)
|
||||
key = f"{file_hash}:{audio}:{resolution}:{segment}"
|
||||
|
||||
# Check if transcode in progress
|
||||
if segment_manager.is_in_progress(key):
|
||||
result = segment_manager.get_segment(
|
||||
key,
|
||||
lambda: transcode_segment(filepath, file_hash, audio, resolution, segment)
|
||||
)
|
||||
if result and os.path.exists(result):
|
||||
trigger_prefetch(filepath, file_hash, audio, resolution, segment, info)
|
||||
with open(result, 'rb') as f:
|
||||
return f.read()
|
||||
return None
|
||||
|
||||
# Fast path: cached
|
||||
if os.path.exists(output):
|
||||
segment_manager.record_cache_hit()
|
||||
trigger_prefetch(filepath, file_hash, audio, resolution, segment, info)
|
||||
with open(output, 'rb') as f:
|
||||
return f.read()
|
||||
|
||||
# Need to transcode
|
||||
result = segment_manager.get_segment(
|
||||
key,
|
||||
lambda: transcode_segment(filepath, file_hash, audio, resolution, segment)
|
||||
)
|
||||
|
||||
if result and os.path.exists(result):
|
||||
trigger_prefetch(filepath, file_hash, audio, resolution, segment, info)
|
||||
with open(result, 'rb') as f:
|
||||
return f.read()
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def trigger_prefetch(filepath: str, file_hash: str, audio: int, resolution: str,
|
||||
current: int, info: dict):
|
||||
"""Prefetch upcoming segments."""
|
||||
duration = float(info.get('format', {}).get('duration', 0))
|
||||
total = int(duration / SEGMENT_DURATION) + 1
|
||||
|
||||
for offset in range(1, PREFETCH_SEGMENTS + 1):
|
||||
next_seg = current + offset
|
||||
if next_seg >= total:
|
||||
break
|
||||
|
||||
output = get_segment_path(file_hash, audio, resolution, next_seg)
|
||||
if os.path.exists(output):
|
||||
continue
|
||||
|
||||
key = f"{file_hash}:{audio}:{resolution}:{next_seg}"
|
||||
seg = next_seg
|
||||
segment_manager.schedule_prefetch(
|
||||
key,
|
||||
lambda s=seg: transcode_segment(filepath, file_hash, audio, resolution, s)
|
||||
)
|
||||
|
||||
|
||||
def generate_master_playlist(info: dict, resolution_filter: str = None, audio_filter: int = None) -> str:
|
||||
"""
|
||||
Generate HLS master playlist.
|
||||
|
||||
Args:
|
||||
info: ffprobe output
|
||||
resolution_filter: Specific resolution (e.g., 'original', '720p') or None for ABR
|
||||
audio_filter: Specific audio track index or None for all tracks
|
||||
|
||||
When audio_filter is specified, generates a simple playlist with just that
|
||||
audio track muxed in - no AUDIO group needed since there's only one option.
|
||||
"""
|
||||
streams = info.get('streams', [])
|
||||
video = next((s for s in streams if s.get('codec_type') == 'video'), None)
|
||||
audio_streams = [s for s in streams if s.get('codec_type') == 'audio']
|
||||
subtitle_streams = [s for s in streams if s.get('codec_type') == 'subtitle']
|
||||
|
||||
lines = ["#EXTM3U", "#EXT-X-VERSION:4", ""]
|
||||
|
||||
# Subtitle tracks
|
||||
sub_counter = 0
|
||||
for i, s in enumerate(subtitle_streams):
|
||||
codec = s.get('codec_name', '')
|
||||
if codec in UNSUPPORTED_SUBTITLE_CODECS:
|
||||
continue
|
||||
lang = s.get('tags', {}).get('language', 'und')
|
||||
title = s.get('tags', {}).get('title', '')
|
||||
name = f"{title}" if title else (lang.upper() if lang != 'und' else f"Subtitle {sub_counter+1}")
|
||||
lines.append(f'#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subs",NAME="{name}",LANGUAGE="{lang}",DEFAULT=NO,AUTOSELECT=YES,URI="subtitle_{i}.m3u8"')
|
||||
sub_counter += 1
|
||||
|
||||
if sub_counter > 0:
|
||||
lines.append("")
|
||||
|
||||
# Video variants
|
||||
if video:
|
||||
src_w = video.get('width', 1920)
|
||||
src_h = video.get('height', 1080)
|
||||
subs_ref = ',SUBTITLES="subs"' if sub_counter > 0 else ''
|
||||
|
||||
# Build quality ladder
|
||||
if resolution_filter:
|
||||
res_info = RESOLUTIONS.get(resolution_filter, RESOLUTIONS['original'])
|
||||
bw_map = {None: 5000000, 1080: 4000000, 720: 2500000, 480: 1200000, 360: 800000}
|
||||
quality_order = [(resolution_filter, res_info[1], bw_map.get(res_info[1], 5000000))]
|
||||
else:
|
||||
quality_order = [
|
||||
('original', None, 5000000),
|
||||
('1080p', 1080, 4000000),
|
||||
('720p', 720, 2500000),
|
||||
('480p', 480, 1200000),
|
||||
('360p', 360, 800000),
|
||||
]
|
||||
|
||||
# Determine audio track to use
|
||||
audio_index = audio_filter if audio_filter is not None else 0
|
||||
|
||||
# Simple playlist - just stream variants, no AUDIO group
|
||||
# Audio is muxed into each stream variant
|
||||
for res_key, target_h, bw in quality_order:
|
||||
if target_h and target_h > src_h:
|
||||
continue
|
||||
if target_h and target_h == src_h:
|
||||
continue
|
||||
|
||||
w, h, _ = RESOLUTIONS.get(res_key, RESOLUTIONS['original'])
|
||||
width = w or src_w
|
||||
height = h or src_h
|
||||
res_label = f"{height}p (Original)" if res_key == 'original' else f"{height}p"
|
||||
|
||||
lines.append(f'#EXT-X-STREAM-INF:BANDWIDTH={bw},RESOLUTION={width}x{height}{subs_ref},NAME="{res_label}"')
|
||||
lines.append(f"stream_a{audio_index}_{res_key}.m3u8")
|
||||
|
||||
return "\n".join(lines) + "\n"
|
||||
|
||||
|
||||
def generate_stream_playlist(info: dict, audio: int, resolution: str) -> str:
|
||||
"""Generate HLS stream playlist with muxed video+audio segments."""
|
||||
duration = float(info.get('format', {}).get('duration', 0))
|
||||
num_segments = int(duration / SEGMENT_DURATION) + 1
|
||||
|
||||
lines = [
|
||||
"#EXTM3U",
|
||||
"#EXT-X-VERSION:3",
|
||||
f"#EXT-X-TARGETDURATION:{SEGMENT_DURATION}",
|
||||
"#EXT-X-MEDIA-SEQUENCE:0",
|
||||
"#EXT-X-PLAYLIST-TYPE:VOD",
|
||||
""
|
||||
]
|
||||
|
||||
for i in range(num_segments):
|
||||
seg_dur = min(SEGMENT_DURATION, duration - (i * SEGMENT_DURATION))
|
||||
if seg_dur > 0.1:
|
||||
lines.append(f"#EXTINF:{seg_dur:.3f},")
|
||||
lines.append(f"seg_a{audio}_{resolution}_{i:05d}.ts")
|
||||
|
||||
lines.append("#EXT-X-ENDLIST")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def generate_subtitle_playlist(info: dict, sub_index: int) -> str:
|
||||
"""Generate subtitle playlist."""
|
||||
duration = float(info.get('format', {}).get('duration', 0))
|
||||
return "\n".join([
|
||||
"#EXTM3U",
|
||||
"#EXT-X-VERSION:3",
|
||||
f"#EXT-X-TARGETDURATION:{int(duration) + 1}",
|
||||
"#EXT-X-MEDIA-SEQUENCE:0",
|
||||
"#EXT-X-PLAYLIST-TYPE:VOD",
|
||||
"",
|
||||
f"#EXTINF:{duration:.3f},",
|
||||
f"subtitle_{sub_index}.vtt",
|
||||
"#EXT-X-ENDLIST"
|
||||
])
|
||||
|
||||
|
||||
def get_metrics() -> dict:
|
||||
"""Get transcoding metrics."""
|
||||
return {
|
||||
**segment_manager.get_metrics(),
|
||||
'adaptive_quality': adaptive_quality.get_stats(),
|
||||
}
|
||||
|
||||
|
||||
def reset_metrics():
|
||||
"""Reset transcoding metrics."""
|
||||
segment_manager.reset_metrics()
|
||||
+737
@@ -0,0 +1,737 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>meta-stremio</title>
|
||||
<style>
|
||||
:root {
|
||||
--bg-primary: #0a0a0f;
|
||||
--bg-secondary: #12121a;
|
||||
--bg-tertiary: #1a1a2e;
|
||||
--text-primary: #e0e0e0;
|
||||
--text-secondary: #a0a0a0;
|
||||
--accent-primary: #4ecdc4;
|
||||
--accent-secondary: #ff6b6b;
|
||||
--accent-warning: #ffd93d;
|
||||
--border-color: #2a2a3e;
|
||||
--success: #4ecdc4;
|
||||
--error: #ff6b6b;
|
||||
}
|
||||
|
||||
* { box-sizing: border-box; margin: 0; padding: 0; }
|
||||
|
||||
body {
|
||||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
|
||||
background: var(--bg-primary);
|
||||
color: var(--text-primary);
|
||||
min-height: 100vh;
|
||||
padding: 2rem;
|
||||
}
|
||||
|
||||
.container { max-width: 1200px; margin: 0 auto; }
|
||||
|
||||
.header {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
margin-bottom: 2rem;
|
||||
padding-bottom: 1rem;
|
||||
border-bottom: 1px solid var(--border-color);
|
||||
}
|
||||
|
||||
.header h1 {
|
||||
font-size: 1.8rem;
|
||||
font-weight: 600;
|
||||
background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
|
||||
-webkit-background-clip: text;
|
||||
background-clip: text;
|
||||
-webkit-text-fill-color: transparent;
|
||||
}
|
||||
|
||||
.header-subtitle {
|
||||
color: var(--text-secondary);
|
||||
font-size: 0.9rem;
|
||||
margin-top: 0.25rem;
|
||||
}
|
||||
|
||||
.grid {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
|
||||
gap: 1.5rem;
|
||||
margin-bottom: 2rem;
|
||||
}
|
||||
|
||||
.card {
|
||||
background: var(--bg-secondary);
|
||||
border-radius: 12px;
|
||||
padding: 1.5rem;
|
||||
border: 1px solid var(--border-color);
|
||||
transition: border-color 0.2s;
|
||||
}
|
||||
|
||||
.card:hover {
|
||||
border-color: rgba(78, 205, 196, 0.3);
|
||||
}
|
||||
|
||||
.card h2 {
|
||||
font-size: 1rem;
|
||||
font-weight: 600;
|
||||
color: var(--text-primary);
|
||||
margin-bottom: 1rem;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
|
||||
.card h2 .icon { font-size: 1.2rem; }
|
||||
|
||||
/* Setup Card */
|
||||
.setup-url {
|
||||
background: var(--bg-tertiary);
|
||||
border-radius: 8px;
|
||||
padding: 1rem;
|
||||
font-family: monospace;
|
||||
font-size: 0.85rem;
|
||||
word-break: break-all;
|
||||
margin-bottom: 1rem;
|
||||
border: 1px solid var(--border-color);
|
||||
color: var(--accent-primary);
|
||||
}
|
||||
|
||||
.btn {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
padding: 0.75rem 1.5rem;
|
||||
border-radius: 8px;
|
||||
text-decoration: none;
|
||||
font-weight: 600;
|
||||
font-size: 0.9rem;
|
||||
transition: all 0.2s;
|
||||
border: none;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.btn-primary {
|
||||
background: var(--accent-primary);
|
||||
color: var(--bg-primary);
|
||||
}
|
||||
|
||||
.btn-primary:hover {
|
||||
transform: translateY(-2px);
|
||||
box-shadow: 0 4px 12px rgba(78, 205, 196, 0.3);
|
||||
}
|
||||
|
||||
.btn-secondary {
|
||||
background: var(--bg-tertiary);
|
||||
color: var(--text-primary);
|
||||
border: 1px solid var(--border-color);
|
||||
}
|
||||
|
||||
.btn-secondary:hover {
|
||||
background: var(--border-color);
|
||||
}
|
||||
|
||||
.btn-group { display: flex; gap: 0.75rem; flex-wrap: wrap; }
|
||||
|
||||
/* Status Indicators */
|
||||
.status {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
padding: 0.25rem 0.75rem;
|
||||
border-radius: 20px;
|
||||
font-size: 0.85rem;
|
||||
font-weight: 500;
|
||||
}
|
||||
|
||||
.status-dot {
|
||||
width: 8px;
|
||||
height: 8px;
|
||||
border-radius: 50%;
|
||||
}
|
||||
|
||||
.status-connected {
|
||||
background: rgba(78, 205, 196, 0.15);
|
||||
color: var(--success);
|
||||
}
|
||||
|
||||
.status-connected .status-dot {
|
||||
background: var(--success);
|
||||
box-shadow: 0 0 8px var(--success);
|
||||
}
|
||||
|
||||
.status-disconnected {
|
||||
background: rgba(255, 107, 107, 0.15);
|
||||
color: var(--error);
|
||||
}
|
||||
|
||||
.status-disconnected .status-dot { background: var(--error); }
|
||||
|
||||
.status-loading {
|
||||
background: rgba(255, 217, 61, 0.15);
|
||||
color: var(--accent-warning);
|
||||
}
|
||||
|
||||
.status-loading .status-dot {
|
||||
background: var(--accent-warning);
|
||||
animation: pulse 1s infinite;
|
||||
}
|
||||
|
||||
@keyframes pulse {
|
||||
0%, 100% { opacity: 1; }
|
||||
50% { opacity: 0.5; }
|
||||
}
|
||||
|
||||
/* Stats */
|
||||
.stats-grid {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(3, 1fr);
|
||||
gap: 1rem;
|
||||
}
|
||||
|
||||
.stat {
|
||||
text-align: center;
|
||||
padding: 1rem;
|
||||
background: var(--bg-tertiary);
|
||||
border-radius: 8px;
|
||||
}
|
||||
|
||||
.stat-value {
|
||||
font-size: 2rem;
|
||||
font-weight: 700;
|
||||
color: var(--accent-primary);
|
||||
}
|
||||
|
||||
.stat-label {
|
||||
font-size: 0.75rem;
|
||||
color: var(--text-secondary);
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.5px;
|
||||
margin-top: 0.25rem;
|
||||
}
|
||||
|
||||
/* Metrics */
|
||||
.metric-row {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
padding: 0.75rem 0;
|
||||
border-bottom: 1px solid var(--border-color);
|
||||
}
|
||||
|
||||
.metric-row:last-child { border-bottom: none; }
|
||||
.metric-label { color: var(--text-secondary); }
|
||||
.metric-value { font-weight: 600; color: var(--text-primary); }
|
||||
.metric-value.good { color: var(--success); }
|
||||
.metric-value.warning { color: var(--accent-warning); }
|
||||
.metric-value.bad { color: var(--error); }
|
||||
|
||||
/* Progress bar */
|
||||
.progress-bar {
|
||||
height: 8px;
|
||||
background: var(--bg-tertiary);
|
||||
border-radius: 4px;
|
||||
overflow: hidden;
|
||||
margin-top: 0.5rem;
|
||||
}
|
||||
|
||||
.progress-fill {
|
||||
height: 100%;
|
||||
border-radius: 4px;
|
||||
transition: width 0.3s ease;
|
||||
}
|
||||
|
||||
.progress-fill.good { background: linear-gradient(90deg, var(--success), #69e0d8); }
|
||||
.progress-fill.warning { background: linear-gradient(90deg, var(--accent-warning), #ffe066); }
|
||||
.progress-fill.bad { background: linear-gradient(90deg, var(--error), #ff8787); }
|
||||
|
||||
/* Steps */
|
||||
.steps { list-style: none; }
|
||||
|
||||
.steps li {
|
||||
padding: 0.75rem 0;
|
||||
padding-left: 2rem;
|
||||
position: relative;
|
||||
border-left: 2px solid var(--border-color);
|
||||
}
|
||||
|
||||
.steps li:before {
|
||||
content: '';
|
||||
position: absolute;
|
||||
left: -6px;
|
||||
top: 1rem;
|
||||
width: 10px;
|
||||
height: 10px;
|
||||
border-radius: 50%;
|
||||
background: var(--accent-primary);
|
||||
}
|
||||
|
||||
.steps li:last-child { border-left-color: transparent; }
|
||||
|
||||
.steps code {
|
||||
background: var(--bg-tertiary);
|
||||
padding: 0.2rem 0.5rem;
|
||||
border-radius: 4px;
|
||||
font-size: 0.85rem;
|
||||
}
|
||||
|
||||
/* Storage info */
|
||||
.storage-info {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
|
||||
.storage-row {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
}
|
||||
|
||||
.storage-type {
|
||||
font-size: 1.1rem;
|
||||
font-weight: 600;
|
||||
color: var(--accent-primary);
|
||||
}
|
||||
|
||||
/* Footer */
|
||||
footer {
|
||||
text-align: center;
|
||||
color: var(--text-secondary);
|
||||
font-size: 0.85rem;
|
||||
margin-top: 2rem;
|
||||
}
|
||||
|
||||
footer a {
|
||||
color: var(--accent-primary);
|
||||
text-decoration: none;
|
||||
}
|
||||
|
||||
footer a:hover { text-decoration: underline; }
|
||||
|
||||
/* Services Navigation */
|
||||
.services-nav {
|
||||
background: var(--bg-secondary);
|
||||
border-radius: 12px;
|
||||
padding: 0.5rem;
|
||||
margin-bottom: 1.5rem;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
flex-wrap: wrap;
|
||||
border: 1px solid var(--border-color);
|
||||
}
|
||||
|
||||
.services-nav-label {
|
||||
color: var(--text-secondary);
|
||||
font-size: 0.85rem;
|
||||
padding: 0.5rem 0.75rem;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.services-nav-items {
|
||||
display: flex;
|
||||
gap: 0.5rem;
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
|
||||
.service-link {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: 0.4rem;
|
||||
padding: 0.5rem 1rem;
|
||||
border-radius: 8px;
|
||||
text-decoration: none;
|
||||
font-size: 0.9rem;
|
||||
font-weight: 500;
|
||||
transition: all 0.2s;
|
||||
color: var(--text-primary);
|
||||
background: var(--bg-tertiary);
|
||||
border: 1px solid var(--border-color);
|
||||
}
|
||||
|
||||
.service-link:hover {
|
||||
background: var(--border-color);
|
||||
border-color: rgba(78, 205, 196, 0.5);
|
||||
}
|
||||
|
||||
.service-link.active {
|
||||
background: linear-gradient(135deg, rgba(78, 205, 196, 0.2), rgba(68, 160, 141, 0.2));
|
||||
border-color: rgba(78, 205, 196, 0.5);
|
||||
}
|
||||
|
||||
.service-link .service-icon { font-size: 1.1rem; }
|
||||
|
||||
.service-link .service-status {
|
||||
width: 6px;
|
||||
height: 6px;
|
||||
border-radius: 50%;
|
||||
background: var(--success);
|
||||
margin-left: 0.25rem;
|
||||
}
|
||||
|
||||
/* Responsive */
|
||||
@media (max-width: 600px) {
|
||||
body { padding: 1rem; }
|
||||
.header h1 { font-size: 1.5rem; }
|
||||
.stats-grid { grid-template-columns: 1fr; }
|
||||
.btn-group { flex-direction: column; }
|
||||
.btn { justify-content: center; }
|
||||
.services-nav { flex-direction: column; align-items: flex-start; }
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<!-- Services Navigation -->
|
||||
<nav class="services-nav" id="servicesNav" style="display: none;">
|
||||
<span class="services-nav-label">Services:</span>
|
||||
<div class="services-nav-items" id="servicesNavItems">
|
||||
<!-- Populated by JavaScript -->
|
||||
</div>
|
||||
</nav>
|
||||
|
||||
<header class="header">
|
||||
<div>
|
||||
<h1>meta-stremio</h1>
|
||||
<p class="header-subtitle">Stream your media library with on-the-fly HLS transcoding</p>
|
||||
</div>
|
||||
</header>
|
||||
|
||||
<div class="grid">
|
||||
<!-- Setup Card -->
|
||||
<div class="card">
|
||||
<h2><span class="icon">🎬</span> Quick Setup</h2>
|
||||
<p style="margin-bottom: 1rem; color: var(--text-secondary);">Install URL for Stremio:</p>
|
||||
<div class="setup-url" id="manifestUrl"></div>
|
||||
<div class="btn-group">
|
||||
<a href="#" id="installLink" class="btn btn-primary">
|
||||
📥 Install in Stremio
|
||||
</a>
|
||||
<button onclick="copyUrl()" class="btn btn-secondary">
|
||||
📋 Copy URL
|
||||
</button>
|
||||
<a href="/configure" class="btn btn-secondary">
|
||||
🌐 Configure Language
|
||||
</a>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Storage Status -->
|
||||
<div class="card">
|
||||
<h2><span class="icon">💾</span> Storage Status</h2>
|
||||
<div class="storage-info">
|
||||
<div class="storage-row">
|
||||
<span class="storage-type" id="storageType">Loading...</span>
|
||||
<span class="status status-loading" id="storageStatus">
|
||||
<span class="status-dot"></span>
|
||||
<span id="storageStatusText">Checking...</span>
|
||||
</span>
|
||||
</div>
|
||||
<div class="storage-row" id="redisUrlRow" style="display: none;">
|
||||
<span class="metric-label">Leader</span>
|
||||
<span class="metric-value" id="redisUrl"></span>
|
||||
</div>
|
||||
<div class="storage-row">
|
||||
<span class="metric-label">Prefix</span>
|
||||
<span class="metric-value" id="storagePrefix">meta-sort:</span>
|
||||
</div>
|
||||
<div style="margin-top: 0.5rem;">
|
||||
<button onclick="refreshLibrary()" class="btn btn-secondary" style="width: 100%;">
|
||||
🔄 Refresh Library
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Library Stats -->
|
||||
<div class="card">
|
||||
<h2><span class="icon">📚</span> Library</h2>
|
||||
<div class="stats-grid">
|
||||
<div class="stat">
|
||||
<div class="stat-value" id="totalVideos">-</div>
|
||||
<div class="stat-label">Total</div>
|
||||
</div>
|
||||
<div class="stat">
|
||||
<div class="stat-value" id="movieCount">-</div>
|
||||
<div class="stat-label">Movies</div>
|
||||
</div>
|
||||
<div class="stat">
|
||||
<div class="stat-value" id="seriesCount">-</div>
|
||||
<div class="stat-label">Series</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Transcoding Metrics -->
|
||||
<div class="card">
|
||||
<h2><span class="icon">⚡</span> Transcoding</h2>
|
||||
<div class="metric-row">
|
||||
<span class="metric-label">Transcode Ratio</span>
|
||||
<span class="metric-value" id="transcodeRatio">-</span>
|
||||
</div>
|
||||
<div class="progress-bar">
|
||||
<div class="progress-fill good" id="ratioBar" style="width: 0%"></div>
|
||||
</div>
|
||||
<div class="metric-row">
|
||||
<span class="metric-label">Active Streams</span>
|
||||
<span class="metric-value" id="activeStreams">0</span>
|
||||
</div>
|
||||
<div class="metric-row">
|
||||
<span class="metric-label">Avg Segment Time</span>
|
||||
<span class="metric-value" id="avgSegmentTime">-</span>
|
||||
</div>
|
||||
<div class="metric-row">
|
||||
<span class="metric-label">Cache Hits</span>
|
||||
<span class="metric-value good" id="cacheHits">-</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Setup Instructions -->
|
||||
<div class="card" style="grid-column: 1 / -1;">
|
||||
<h2><span class="icon">📖</span> Setup Instructions</h2>
|
||||
<ol class="steps">
|
||||
<li>
|
||||
<strong>Install Stremio</strong><br>
|
||||
<span style="color: var(--text-secondary);">Download from</span> <a href="https://www.stremio.com" target="_blank">stremio.com</a>
|
||||
</li>
|
||||
<li>
|
||||
<strong>Add this addon</strong><br>
|
||||
<span style="color: var(--text-secondary);">Click "Install in Stremio" above, or paste the URL into Stremio's addon search</span>
|
||||
</li>
|
||||
<li>
|
||||
<strong>Browse your library</strong><br>
|
||||
<span style="color: var(--text-secondary);">Your videos indexed by meta-sort will appear in the addon's catalog</span>
|
||||
</li>
|
||||
<li>
|
||||
<strong>Start streaming</strong><br>
|
||||
<span style="color: var(--text-secondary);">Select a video and choose your preferred stream quality</span>
|
||||
</li>
|
||||
</ol>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<footer>
|
||||
<p>Part of the <a href="https://github.com/user/metamesh">MetaMesh</a> ecosystem</p>
|
||||
<p style="margin-top: 0.5rem;">Powered by meta-sort metadata | FFmpeg HLS transcoding</p>
|
||||
</footer>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
const baseUrl = window.location.origin;
|
||||
const manifestUrl = `${baseUrl}/manifest.json`;
|
||||
|
||||
// Set URLs
|
||||
document.getElementById('manifestUrl').textContent = manifestUrl;
|
||||
document.getElementById('installLink').href = `stremio://${window.location.host}/manifest.json`;
|
||||
|
||||
function copyUrl() {
|
||||
navigator.clipboard.writeText(manifestUrl).then(() => {
|
||||
const btn = event.target.closest('.btn');
|
||||
const original = btn.innerHTML;
|
||||
btn.innerHTML = '✓ Copied!';
|
||||
setTimeout(() => btn.innerHTML = original, 2000);
|
||||
});
|
||||
}
|
||||
|
||||
async function fetchStorageStatus() {
|
||||
try {
|
||||
const res = await fetch('/api/storage-status');
|
||||
const data = await res.json();
|
||||
|
||||
const statusEl = document.getElementById('storageStatus');
|
||||
const statusText = document.getElementById('storageStatusText');
|
||||
const typeEl = document.getElementById('storageType');
|
||||
|
||||
// Display storage type
|
||||
const typeNames = {
|
||||
'leader': 'Leader Discovery',
|
||||
'redis': 'Redis Direct'
|
||||
};
|
||||
typeEl.textContent = typeNames[data.type] || data.type;
|
||||
|
||||
if (data.connected) {
|
||||
statusEl.className = 'status status-connected';
|
||||
statusText.textContent = 'Connected';
|
||||
} else {
|
||||
statusEl.className = 'status status-disconnected';
|
||||
statusText.textContent = 'Disconnected';
|
||||
}
|
||||
|
||||
// Show leader info for leader mode
|
||||
const redisUrlRow = document.getElementById('redisUrlRow');
|
||||
if (data.leader && data.leader.api) {
|
||||
redisUrlRow.style.display = 'flex';
|
||||
document.getElementById('redisUrl').textContent = data.leader.host + ' (' + data.leader.api.replace('redis://', '') + ')';
|
||||
} else if (data.type === 'redis' && data.url) {
|
||||
redisUrlRow.style.display = 'flex';
|
||||
document.getElementById('redisUrl').textContent = data.url.replace(/\/\/[^:]+:[^@]+@/, '//***:***@');
|
||||
} else {
|
||||
redisUrlRow.style.display = 'none';
|
||||
}
|
||||
|
||||
if (data.prefix) {
|
||||
document.getElementById('storagePrefix').textContent = data.prefix;
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('Failed to fetch storage status:', e);
|
||||
}
|
||||
}
|
||||
|
||||
async function fetchStats() {
|
||||
try {
|
||||
const res = await fetch('/api/stats');
|
||||
const data = await res.json();
|
||||
|
||||
document.getElementById('totalVideos').textContent = data.total || 0;
|
||||
document.getElementById('movieCount').textContent = data.movies || 0;
|
||||
document.getElementById('seriesCount').textContent = data.series || 0;
|
||||
} catch (e) {
|
||||
console.error('Failed to fetch stats:', e);
|
||||
}
|
||||
}
|
||||
|
||||
async function fetchMetrics() {
|
||||
try {
|
||||
const res = await fetch('/transcode/metrics');
|
||||
const data = await res.json();
|
||||
|
||||
// Transcode ratio
|
||||
const ratio = data.transcode_ratio || 0;
|
||||
const ratioPercent = Math.round(ratio * 100);
|
||||
document.getElementById('transcodeRatio').textContent = `${ratioPercent}%`;
|
||||
|
||||
const ratioBar = document.getElementById('ratioBar');
|
||||
ratioBar.style.width = `${ratioPercent}%`;
|
||||
|
||||
// Color based on target (60-80% is ideal)
|
||||
if (ratio >= 0.6 && ratio <= 0.8) {
|
||||
ratioBar.className = 'progress-fill good';
|
||||
} else if (ratio >= 0.5 && ratio <= 0.9) {
|
||||
ratioBar.className = 'progress-fill warning';
|
||||
} else {
|
||||
ratioBar.className = 'progress-fill bad';
|
||||
}
|
||||
|
||||
// Active streams
|
||||
document.getElementById('activeStreams').textContent = data.active_transcodes || 0;
|
||||
|
||||
// Avg segment time
|
||||
const avgTime = data.avg_segment_time;
|
||||
if (avgTime !== undefined && avgTime !== null) {
|
||||
document.getElementById('avgSegmentTime').textContent = `${avgTime.toFixed(2)}s`;
|
||||
}
|
||||
|
||||
// Cache hits
|
||||
const total = (data.cache_hits || 0) + (data.cache_misses || 0);
|
||||
if (total > 0) {
|
||||
const hitRate = Math.round((data.cache_hits / total) * 100);
|
||||
document.getElementById('cacheHits').textContent = `${hitRate}% (${data.cache_hits}/${total})`;
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('Failed to fetch metrics:', e);
|
||||
}
|
||||
}
|
||||
|
||||
async function refreshLibrary() {
|
||||
try {
|
||||
const btn = event.target.closest('.btn');
|
||||
btn.disabled = true;
|
||||
btn.innerHTML = '⏳ Refreshing...';
|
||||
|
||||
await fetch('/api/library/refresh', { method: 'POST' });
|
||||
|
||||
await fetchStats();
|
||||
await fetchStorageStatus();
|
||||
|
||||
btn.innerHTML = '✓ Refreshed!';
|
||||
setTimeout(() => {
|
||||
btn.disabled = false;
|
||||
btn.innerHTML = '🔄 Refresh Library';
|
||||
}, 2000);
|
||||
} catch (e) {
|
||||
console.error('Failed to refresh library:', e);
|
||||
const btn = event.target.closest('.btn');
|
||||
btn.disabled = false;
|
||||
btn.innerHTML = '❌ Failed';
|
||||
setTimeout(() => {
|
||||
btn.innerHTML = '🔄 Refresh Library';
|
||||
}, 2000);
|
||||
}
|
||||
}
|
||||
|
||||
// Service icons mapping
|
||||
const serviceIcons = {
|
||||
'meta-sort': '📁',
|
||||
'meta-fuse': '🗂️',
|
||||
'meta-stremio': '🎬',
|
||||
'meta-orbit': '🌐',
|
||||
'default': '📦'
|
||||
};
|
||||
|
||||
// Fetch and display discovered services
|
||||
async function fetchServices() {
|
||||
try {
|
||||
const res = await fetch('/api/services');
|
||||
const data = await res.json();
|
||||
|
||||
const navEl = document.getElementById('servicesNav');
|
||||
const itemsEl = document.getElementById('servicesNavItems');
|
||||
|
||||
if (data.services && data.services.length > 0) {
|
||||
// Sort services by name
|
||||
const services = data.services.sort((a, b) => a.name.localeCompare(b.name));
|
||||
|
||||
// Build navigation items
|
||||
itemsEl.innerHTML = services.map(svc => {
|
||||
const icon = serviceIcons[svc.name] || serviceIcons.default;
|
||||
const isActive = svc.name === data.current;
|
||||
const activeClass = isActive ? ' active' : '';
|
||||
|
||||
// Use external URL for other services, current path for self
|
||||
const href = isActive ? '#' : svc.url;
|
||||
|
||||
return `
|
||||
<a href="${href}" class="service-link${activeClass}" onclick="event.preventDefault(); ${isActive ? '' : `window.location.href='${svc.url}'`}">
|
||||
<span class="service-icon">${icon}</span>
|
||||
<span>${formatServiceName(svc.name)}</span>
|
||||
<span class="service-status"></span>
|
||||
</a>
|
||||
`;
|
||||
}).join('');
|
||||
|
||||
navEl.style.display = 'flex';
|
||||
} else {
|
||||
navEl.style.display = 'none';
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('Failed to fetch services:', e);
|
||||
document.getElementById('servicesNav').style.display = 'none';
|
||||
}
|
||||
}
|
||||
|
||||
function formatServiceName(name) {
|
||||
// Convert 'meta-stremio' to 'Meta Stremio'
|
||||
return name.split('-').map(word =>
|
||||
word.charAt(0).toUpperCase() + word.slice(1)
|
||||
).join(' ');
|
||||
}
|
||||
|
||||
// Initial fetch
|
||||
fetchStorageStatus();
|
||||
fetchStats();
|
||||
fetchMetrics();
|
||||
fetchServices();
|
||||
|
||||
// Refresh metrics every 5 seconds
|
||||
setInterval(fetchMetrics, 5000);
|
||||
|
||||
// Refresh stats every 30 seconds
|
||||
setInterval(fetchStats, 30000);
|
||||
|
||||
// Refresh services every 60 seconds
|
||||
setInterval(fetchServices, 60000);
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
Reference in New Issue
Block a user