Harvey
0f25ebc26d
* plex integration * The big one - Full Music Source page rework + Playlist importing + Full Plex Integration + Discovery Options + More Like This/Surprise Me/Instant Mix + More... * Music source track page - Play all / shuffle fixes * lint * format * fix type checks * format
299 lines
12 KiB
Python
299 lines
12 KiB
Python
import logging
|
|
|
|
from fastapi import APIRouter, Body, Depends, HTTPException, Request
|
|
from fastapi.responses import Response, StreamingResponse
|
|
|
|
from api.v1.schemas.stream import (
|
|
PlaybackSessionResponse,
|
|
ProgressReportRequest,
|
|
StartPlaybackRequest,
|
|
StopReportRequest,
|
|
)
|
|
from core.dependencies import (
|
|
get_jellyfin_playback_service,
|
|
get_local_files_service,
|
|
get_navidrome_playback_service,
|
|
get_plex_playback_service,
|
|
)
|
|
from core.exceptions import ExternalServiceError, PlaybackNotAllowedError, ResourceNotFoundError
|
|
from infrastructure.msgspec_fastapi import MsgSpecBody, MsgSpecRoute
|
|
from services.jellyfin_playback_service import JellyfinPlaybackService
|
|
from services.local_files_service import LocalFilesService
|
|
from services.navidrome_playback_service import NavidromePlaybackService
|
|
from services.plex_playback_service import PlexPlaybackService
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
router = APIRouter(route_class=MsgSpecRoute, prefix="/stream", tags=["streaming"])
|
|
|
|
|
|
@router.get("/jellyfin/{item_id}")
|
|
async def stream_jellyfin_audio(
|
|
item_id: str,
|
|
request: Request,
|
|
playback_service: JellyfinPlaybackService = Depends(get_jellyfin_playback_service),
|
|
) -> StreamingResponse:
|
|
try:
|
|
range_header = request.headers.get("Range")
|
|
return await playback_service.proxy_stream(item_id, range_header=range_header)
|
|
except ResourceNotFoundError:
|
|
raise HTTPException(status_code=404, detail="Audio item not found")
|
|
except PlaybackNotAllowedError as e:
|
|
logger.warning("Playback not allowed for %s: %s", item_id, e)
|
|
raise HTTPException(status_code=403, detail="Playback not allowed")
|
|
except ExternalServiceError as e:
|
|
if "416" in str(e):
|
|
raise HTTPException(status_code=416, detail="Range not satisfiable")
|
|
raise HTTPException(status_code=502, detail="Failed to stream from Jellyfin")
|
|
|
|
|
|
@router.head("/jellyfin/{item_id}")
|
|
async def head_jellyfin_audio(
|
|
item_id: str,
|
|
playback_service: JellyfinPlaybackService = Depends(get_jellyfin_playback_service),
|
|
) -> Response:
|
|
try:
|
|
return await playback_service.proxy_head(item_id)
|
|
except ResourceNotFoundError:
|
|
raise HTTPException(status_code=404, detail="Audio item not found")
|
|
except PlaybackNotAllowedError as e:
|
|
logger.warning("Playback not allowed for %s: %s", item_id, e)
|
|
raise HTTPException(status_code=403, detail="Playback not allowed")
|
|
except ExternalServiceError as e:
|
|
logger.error("Jellyfin head stream error for %s: %s", item_id, e)
|
|
raise HTTPException(status_code=502, detail="Failed to resolve Jellyfin stream")
|
|
|
|
|
|
@router.post("/jellyfin/{item_id}/start", response_model=PlaybackSessionResponse)
|
|
async def start_jellyfin_playback(
|
|
item_id: str,
|
|
body: StartPlaybackRequest | None = Body(default=None),
|
|
playback_service: JellyfinPlaybackService = Depends(get_jellyfin_playback_service),
|
|
) -> PlaybackSessionResponse:
|
|
try:
|
|
play_session_id = await playback_service.start_playback(
|
|
item_id,
|
|
play_session_id=body.play_session_id if body else None,
|
|
)
|
|
return PlaybackSessionResponse(play_session_id=play_session_id, item_id=item_id)
|
|
except ResourceNotFoundError:
|
|
raise HTTPException(status_code=404, detail="Item not found")
|
|
except PlaybackNotAllowedError as e:
|
|
logger.warning("Playback not allowed for %s: %s", item_id, e)
|
|
raise HTTPException(status_code=403, detail="Playback not allowed")
|
|
except ExternalServiceError as e:
|
|
logger.error("Failed to start playback for %s: %s", item_id, e)
|
|
raise HTTPException(status_code=502, detail="Failed to start Jellyfin playback")
|
|
|
|
|
|
@router.post("/jellyfin/{item_id}/progress", status_code=204)
|
|
async def report_jellyfin_progress(
|
|
item_id: str,
|
|
body: ProgressReportRequest = MsgSpecBody(ProgressReportRequest),
|
|
playback_service: JellyfinPlaybackService = Depends(get_jellyfin_playback_service),
|
|
) -> Response:
|
|
try:
|
|
await playback_service.report_progress(
|
|
item_id=item_id,
|
|
play_session_id=body.play_session_id,
|
|
position_seconds=body.position_seconds,
|
|
is_paused=body.is_paused,
|
|
)
|
|
return Response(status_code=204)
|
|
except ExternalServiceError as e:
|
|
logger.warning("Progress report failed for %s: %s", item_id, e)
|
|
raise HTTPException(status_code=502, detail="Failed to report progress")
|
|
|
|
|
|
@router.post("/jellyfin/{item_id}/stop", status_code=204)
|
|
async def stop_jellyfin_playback(
|
|
item_id: str,
|
|
body: StopReportRequest = MsgSpecBody(StopReportRequest),
|
|
playback_service: JellyfinPlaybackService = Depends(get_jellyfin_playback_service),
|
|
) -> Response:
|
|
try:
|
|
await playback_service.stop_playback(
|
|
item_id=item_id,
|
|
play_session_id=body.play_session_id,
|
|
position_seconds=body.position_seconds,
|
|
)
|
|
return Response(status_code=204)
|
|
except ExternalServiceError as e:
|
|
logger.warning("Stop report failed for %s: %s", item_id, e)
|
|
raise HTTPException(status_code=502, detail="Failed to report playback stop")
|
|
|
|
|
|
@router.head("/local/{track_id}")
|
|
async def head_local_file(
|
|
track_id: int,
|
|
local_service: LocalFilesService = Depends(get_local_files_service),
|
|
) -> Response:
|
|
try:
|
|
headers = await local_service.head_track(track_id)
|
|
return Response(
|
|
status_code=200,
|
|
headers=headers,
|
|
media_type=headers.get("Content-Type", "application/octet-stream"),
|
|
)
|
|
except ResourceNotFoundError:
|
|
raise HTTPException(status_code=404, detail="Track file not found")
|
|
except FileNotFoundError:
|
|
raise HTTPException(status_code=404, detail="Track file not found on disk")
|
|
except PermissionError:
|
|
raise HTTPException(status_code=403, detail="Access denied: path is outside the music directory")
|
|
except ExternalServiceError as e:
|
|
logger.error("Local head error for track %s: %s", track_id, e)
|
|
raise HTTPException(status_code=502, detail="Failed to check local file")
|
|
except OSError as e:
|
|
logger.error("OS error checking local track %s: %s", track_id, e)
|
|
raise HTTPException(status_code=500, detail="Failed to read local file")
|
|
|
|
|
|
@router.get("/local/{track_id}")
|
|
async def stream_local_file(
|
|
track_id: int,
|
|
request: Request,
|
|
local_service: LocalFilesService = Depends(get_local_files_service),
|
|
) -> StreamingResponse:
|
|
try:
|
|
range_header = request.headers.get("Range")
|
|
chunks, headers, status_code = await local_service.stream_track(
|
|
track_file_id=track_id,
|
|
range_header=range_header,
|
|
)
|
|
return StreamingResponse(
|
|
content=chunks,
|
|
status_code=status_code,
|
|
headers=headers,
|
|
media_type=headers.get("Content-Type", "application/octet-stream"),
|
|
)
|
|
except ResourceNotFoundError:
|
|
raise HTTPException(status_code=404, detail="Track file not found")
|
|
except FileNotFoundError:
|
|
raise HTTPException(status_code=404, detail="Track file not found on disk")
|
|
except PermissionError:
|
|
raise HTTPException(status_code=403, detail="Access denied: path is outside the music directory")
|
|
except ExternalServiceError as e:
|
|
detail = str(e)
|
|
if "Range not satisfiable" in detail:
|
|
raise HTTPException(status_code=416, detail="Range not satisfiable")
|
|
logger.error("Local stream error for track %s: %s", track_id, e)
|
|
raise HTTPException(status_code=502, detail="Failed to stream local file")
|
|
except OSError as e:
|
|
logger.error("OS error streaming local track %s: %s", track_id, e)
|
|
raise HTTPException(status_code=500, detail="Failed to read local file")
|
|
|
|
|
|
@router.head("/navidrome/{item_id}")
|
|
async def head_navidrome_audio(
|
|
item_id: str,
|
|
playback_service: NavidromePlaybackService = Depends(get_navidrome_playback_service),
|
|
) -> Response:
|
|
try:
|
|
return await playback_service.proxy_head(item_id)
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid stream request")
|
|
except ExternalServiceError:
|
|
raise HTTPException(status_code=502, detail="Failed to stream from Navidrome")
|
|
|
|
|
|
@router.get("/navidrome/{item_id}")
|
|
async def stream_navidrome_audio(
|
|
item_id: str,
|
|
request: Request,
|
|
playback_service: NavidromePlaybackService = Depends(get_navidrome_playback_service),
|
|
) -> StreamingResponse:
|
|
try:
|
|
return await playback_service.proxy_stream(item_id, request.headers.get("Range"))
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid stream request")
|
|
except ExternalServiceError as e:
|
|
detail = str(e)
|
|
if "416" in detail or "Range not satisfiable" in detail:
|
|
raise HTTPException(status_code=416, detail="Range not satisfiable")
|
|
raise HTTPException(status_code=502, detail="Failed to stream from Navidrome")
|
|
|
|
|
|
@router.post("/navidrome/{item_id}/scrobble")
|
|
async def scrobble_navidrome(
|
|
item_id: str,
|
|
playback_service: NavidromePlaybackService = Depends(get_navidrome_playback_service),
|
|
) -> dict[str, str]:
|
|
ok = await playback_service.scrobble(item_id)
|
|
return {"status": "ok" if ok else "error"}
|
|
|
|
|
|
@router.post("/navidrome/{item_id}/now-playing")
|
|
async def navidrome_now_playing(
|
|
item_id: str,
|
|
playback_service: NavidromePlaybackService = Depends(get_navidrome_playback_service),
|
|
) -> dict[str, str]:
|
|
ok = await playback_service.report_now_playing(item_id)
|
|
return {"status": "ok" if ok else "error"}
|
|
|
|
|
|
@router.post("/navidrome/{item_id}/stopped")
|
|
async def navidrome_stopped(
|
|
item_id: str,
|
|
playback_service: NavidromePlaybackService = Depends(get_navidrome_playback_service),
|
|
) -> dict[str, str]:
|
|
await playback_service.clear_now_playing(item_id)
|
|
return {"status": "ok"}
|
|
|
|
|
|
@router.head("/plex/{part_key:path}")
|
|
async def head_plex_audio(
|
|
part_key: str,
|
|
playback_service: PlexPlaybackService = Depends(get_plex_playback_service),
|
|
) -> Response:
|
|
try:
|
|
return await playback_service.proxy_head(part_key)
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid stream request")
|
|
except ExternalServiceError:
|
|
raise HTTPException(status_code=502, detail="Failed to stream from Plex")
|
|
|
|
|
|
@router.get("/plex/{part_key:path}")
|
|
async def stream_plex_audio(
|
|
part_key: str,
|
|
request: Request,
|
|
playback_service: PlexPlaybackService = Depends(get_plex_playback_service),
|
|
) -> StreamingResponse:
|
|
try:
|
|
return await playback_service.proxy_stream(part_key, request.headers.get("Range"))
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid stream request")
|
|
except ExternalServiceError as e:
|
|
detail = str(e)
|
|
if "416" in detail or "Range not satisfiable" in detail:
|
|
raise HTTPException(status_code=416, detail="Range not satisfiable")
|
|
raise HTTPException(status_code=502, detail="Failed to stream from Plex")
|
|
|
|
|
|
@router.post("/plex/{rating_key}/scrobble")
|
|
async def scrobble_plex(
|
|
rating_key: str,
|
|
playback_service: PlexPlaybackService = Depends(get_plex_playback_service),
|
|
) -> dict[str, str]:
|
|
ok = await playback_service.scrobble(rating_key)
|
|
return {"status": "ok" if ok else "error"}
|
|
|
|
|
|
@router.post("/plex/{rating_key}/now-playing")
|
|
async def plex_now_playing(
|
|
rating_key: str,
|
|
playback_service: PlexPlaybackService = Depends(get_plex_playback_service),
|
|
) -> dict[str, str]:
|
|
ok = await playback_service.report_now_playing(rating_key)
|
|
return {"status": "ok" if ok else "error"}
|
|
|
|
|
|
@router.post("/plex/{rating_key}/stopped")
|
|
async def plex_stopped(
|
|
rating_key: str,
|
|
playback_service: PlexPlaybackService = Depends(get_plex_playback_service),
|
|
) -> dict[str, str]:
|
|
ok = await playback_service.report_stopped(rating_key)
|
|
return {"status": "ok" if ok else "error"}
|