952 lines
36 KiB
Python
952 lines
36 KiB
Python
#!/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: /files/watch)
|
|
- CACHE_DIR: Directory for transcoded segments (default: /data/cache)
|
|
- PORT: HTTP server port (default: 7000)
|
|
- STORAGE_MODE: Storage backend 'leader' or 'redis' (default: redis)
|
|
- META_CORE_PATH: Path to meta-core shared volume (default: /meta-core)
|
|
- REDIS_URL: Redis connection URL (default: redis://localhost:6379)
|
|
- REDIS_PREFIX: Redis key prefix (default: empty)
|
|
- SCHEME: URL scheme for generated URLs - http/https/auto (default: 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
|
|
import webdav_client
|
|
|
|
# Configuration
|
|
PORT = int(os.environ.get('PORT', '7000'))
|
|
SCHEME = os.environ.get('SCHEME', 'auto').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:
|
|
# Check if file exists (works with both local and WebDAV)
|
|
if webdav_client.file_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, full_path)
|
|
|
|
data = transcoder.get_or_transcode_segment(full_path, 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:
|
|
# Check if file exists (works with both local and WebDAV)
|
|
if webdav_client.file_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')
|
|
|
|
# Get file size (works with both local and WebDAV)
|
|
file_size = webdav_client.get_file_size(full_path)
|
|
if file_size is None:
|
|
self.send_error(500, f"Could not get file size: {filepath}")
|
|
return
|
|
|
|
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()
|
|
|
|
# Stream the range (works with both local and WebDAV)
|
|
for chunk in webdav_client.stream_range(full_path, start, end, file_size):
|
|
self.wfile.write(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()
|
|
|
|
# Stream the entire file (works with both local and WebDAV)
|
|
for chunk in webdav_client.stream_file(full_path):
|
|
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()
|