plex

type AccessPolicy ¶

type AccessPolicy = frontend.AccessPolicy

AccessPolicy adds owner-defined restrictions to the mandatory title guard.

type CollectionArtworker ¶

type CollectionArtworker interface {
	CollectionArtwork(ctx context.Context, user *frontend.Viewer, key frontend.RatingKey, element string, width int) (data []byte, contentType string, ok bool, err error)
}

CollectionArtworker is optionally implemented by Deps.Collections to serve generated collection posters (internal/collections renders them with internal/artwork). ok=false falls back to the TMDB artwork path.

type Deps ¶

type Deps struct {
	Host       frontend.Host
	Playback   frontend.Playback
	Transcoder frontend.Transcoder

	// Sections overrides the default Movies (1) and TV Shows (2) sections.
	Sections []Section
	// DB persists artwork data and ordered shelf-generation keys. Clustered
	// nodes share this store so continuations survive failover and restarts.
	// Optional: without it, these caches remain process-local.
	DB *sql.DB
	// DisableEnrichment turns off the background title-detail and
	// UltraBlurColors work (the spike test library has nothing to fetch).
	DisableEnrichment bool
	// TracePlayback logs HLS/transcode requests when ETHER_TRACE_PLAYBACK=1.
	// It does not change responses.
	TracePlayback bool
}

Deps are the server's dependencies. Host.Experience, Host.Identity and Host.Sessions are required; the rest degrade gracefully when nil.

type Directive ¶

type Directive struct {
	Verb string
	Args map[string]string
}

Directive is one parsed X-Plex-Client-Profile-Extra directive, e.g. add-limitation(scope=videoCodec&scopeName=h264&...).

func ParseProfileExtra(s string) []Directive

type DiscoveryFeatures ¶

type DiscoveryFeatures = frontend.DiscoveryFeatures

DiscoveryFeatures is the shared discovery contract adapted by Plex.

type Frontend ¶

type Frontend struct {
	NewServer    func() (*Server, error)
	Server       *Server
	WatchRefresh frontend.WatchRefreshSubscriber
	// ExplicitWatchOnly preserves spike mode: only cross-surface scrobbles refresh.
	ExplicitWatchOnly bool
	StatusFunc        func(context.Context) frontend.Status
	ListenersFunc     func() []frontend.ListenerSpec
	// contains filtered or unexported fields
}

Frontend adapts the PMS handler to the frontend registry. Unmount stops this mount's broker sessions, encoders, trickplay, and downloads, and drops its watch and home subscriptions. When constructed via NewFrontend, the process-owned server stays up across toggles so an in-flight request can finish and is closed on Shutdown.

func NewFrontend() Frontend

func (f Frontend) Describe() frontend.Descriptor

func (f Frontend) HasRetainedServer() bool

func (f Frontend) Mount(ctx context.Context, host frontend.Host) (frontend.Instance, error)

func (f Frontend) Prune(ctx context.Context) (int64, error)

func (f Frontend) Shutdown(context.Context) error

type FrontendArtwork ¶

type FrontendArtwork struct {
	Server        *Server
	Variants      func(*frontend.Title, string) (*frontend.ArtworkImages, bool)
	Metadata      func(context.Context, frontend.ArtworkRequest, frontend.Image) frontend.Image
	VirtualSeason func(context.Context, *frontend.User, frontend.RatingKey) (*frontend.Title, error)
	URLImages     frontend.UntrustedImageFetcher
	Raster        frontend.SVGRasterizer
}

FrontendArtwork is a compatibility adapter for callers already holding a Plex server. Shared runtime constructs artworkservice.Source directly.

func (a FrontendArtwork) ChannelImage(v *frontend.Viewer, c frontend.LiveTVChannel) frontend.Image

func (a FrontendArtwork) ImageURLFunc() frontend.ImageURLFunc

func (a FrontendArtwork) List(ctx context.Context, req frontend.ArtworkRequest) ([]frontend.Image, bool, error)

func (a FrontendArtwork) PaletteCache() frontend.ArtworkPaletteCache

func (a FrontendArtwork) PosterRenderer() frontend.TitlePosterRenderer

func (a FrontendArtwork) Read(ctx context.Context, req frontend.ArtworkRequest, img frontend.Image, tr frontend.ArtworkTransform) ([]byte, string, error)

func (a FrontendArtwork) RemoteCache() frontend.ArtworkImageCache

func (a FrontendArtwork) Warm(t frontend.Title, d frontend.Device)

type Identity ¶

type Identity struct {
	MachineIdentifier  string
	FriendlyName       string
	Version            string
	Platform           string
	PlatformVersion    string
	MyPlexSubscription bool
	OwnerFeatures      []string
}

Identity is how the server presents itself. Empty fields fall back to the config snapshot (friendly name, machine identifier) or sensible defaults.

type MarkerProvider ¶

type MarkerProvider = frontend.MarkerRanges

type Request ¶

type Request struct {
	Token           string
	ClientID        string // X-Plex-Client-Identifier
	Product         string // X-Plex-Product
	Version         string // X-Plex-Version
	Platform        string // X-Plex-Platform
	PlatformVersion string // X-Plex-Platform-Version
	Device          string // X-Plex-Device
	DeviceName      string // X-Plex-Device-Name
	Model           string // X-Plex-Model
	Vendor          string // X-Plex-Device-Vendor
	Language        string // X-Plex-Language

	Features     string // X-Plex-Features
	ProfileName  string // X-Plex-Client-Profile-Name
	ProfileExtra string // X-Plex-Client-Profile-Extra

	ClientCapabilities string // X-Plex-Client-Capabilities (legacy)
	SessionID          string // X-Plex-Session-Identifier

	// Paging (X-Plex-Container-Start/Size); HasPage is false when the client
	// did not ask for a window.
	Start   int
	Size    int
	HasPage bool

	Format model.Format

	RemoteIP netip.Addr
	Remote   bool // not on a private/loopback network

	User *frontend.User

	// Capability is set when authentication used a stream grant or other
	// session-scoped credential, not a user token. Only transcode
	// session/segment handlers may serve a capability-scoped request.
	Capability bool
	// contains filtered or unexported fields
}

Request is the parsed Plex request context: every X-Plex-* header (or its query-string equivalent), paging, the output format and the remote address.

func FromContext(ctx context.Context) *Request

func ParseRequest(r *http.Request, trusted ...netip.Prefix) *Request

func (pr *Request) ClientCaps(remoteMaxKbps int) frontend.ClientCaps

func (pr *Request) ClientCapsWith(remoteMaxKbps int, overrides []frontend.ClientCapabilityOverride) frontend.ClientCaps

type Section ¶

type Section struct {
	ID       int
	Type     frontend.MediaType // movie or show
	Title    string
	UUID     string // stable; derived from the machine identifier when empty
	Language string
}

Section is a library section exposed to clients.

type SegmentedEncoder ¶

type SegmentedEncoder = frontend.SegmentedEncoder

SegmentedEncoder is an opt-in trusted host seam implemented by the shared broker. Starts occur only after existing Plex authentication, owner gates, preparation and admission. The broker must revalidate the exact source revision and retain uncertain execution responsibility. It may choose local execution only before remote allocation; a returned error is never permission for Plex to retry local. Session/Stop true means the broker owns responsibility, even when Session is nil because start is pending. Transport errors must never turn true into false.

type Server ¶

type Server struct {
	// contains filtered or unexported fields
}

Server is the PMS API handler. It is an http.Handler; call Close on shutdown to stop background work and notification streams.

func NewServer(d Deps) *Server

func (s *Server) BackgroundBusy() int

func (s *Server) Close() error

func (s *Server) Closed() bool

func (s *Server) Done() <-chan struct{}

func (s *Server) DownloadsAllowed(u *frontend.User) bool

func (s *Server) LibrarySections() []Section

func (s *Server) NoteOwnerStop(id, reason string)

func (s *Server) NotifyLiveLineup()

func (s *Server) NotifyLiveLineupFor(viewer int64)

func (s *Server) Prune(ctx context.Context) (int64, error)

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (s *Server) SupportViewer(ctx context.Context, user *frontend.Viewer) (frontend.DiagnosticViewerFacts, error)

func (s *Server) ViewerHomeChanged(viewerID int64)

func (s *Server) WatchStateChanged(userID int64, key frontend.RatingKey)

type SessionToucher ¶

type SessionToucher interface {
	Touch(sessionID string)
}

SessionToucher is optionally implemented by frontend.Playback to keep a play session alive on timeline updates.

type SubtitleCatalog ¶

type SubtitleCatalog = frontend.SubtitleSidecarCatalog

SubtitleCatalog is optionally implemented by Deps.Subtitles: the sidecars already cached for a title and viewer, without network access, skipping streams embedded already lists (by ExternalURL) or covers (by language).

type SubtitleOffer ¶

type SubtitleOffer = frontend.SubtitleSearchOffer

SubtitleOffer is one subtitle search result.

type SubtitleSearch ¶

type SubtitleSearch = frontend.SubtitleSidecarSearch

SubtitleSearch is optionally implemented by Deps.Subtitles: Plex's on-demand subtitle search and pick.

type SubtitleSource ¶

type SubtitleSource = frontend.SubtitleSidecarSource

SubtitleSource resolves cached OpenSubtitles and synchronized sidecars.

type SubtitleUpload ¶

type SubtitleUpload = frontend.SubtitleSidecarUpload

SubtitleUpload is optionally implemented by Deps.Subtitles: Plex Web's "Upload Subtitles" (POST /library/metadata/{key}/subtitles).

type TrackPreferences ¶

type TrackPreferences = frontend.PlaybackTrackPreferences

TrackPreferences is optional. Selections are stream slice positions; saved show choices match language/flags so they survive changes in release order.