resolver

type Checker ¶

type Checker interface {
	Check(ctx context.Context, urls []string) ([]core.Availability, error)
}

Checker is the optional other half of a resolver: a backend that can be asked whether a link is still there without fetching it. Implementing it is what moves a service's links off core.AvailUnknown, which says "nobody has looked" and is a lie the moment somebody presses Check.

The batch is the interface and not an optimisation inside it. Every service that answers this question answers it for a list, and a caller holding fifty links that asks fifty times is a caller whose key gets rate-limited - so the one-link form is deliberately absent, because it is the shape that would get written by accident.

The contract is one verdict per URL, in the order they were given. A service that cannot answer for a particular link returns core.AvailUncheckable for it rather than dropping it, because a short slice silently re-aligns every verdict after the gap onto the wrong link. Callers should still run the answer through Answers, which is the only cheap defence against a service that changes its mind about that.

An error means the batch was not answered at all - a refused key, a service that is down. It never means "these links are gone": the caller files the whole batch as uncheckable and says so.

type Direct ¶

type Direct struct{}

Direct handles plain http(s) links whose path names a file; the URL is already the download target and is fetched by the embedded engine.

func (Direct) Info() Info

func (Direct) Match(raw string) bool

func (Direct) Resolve(_ context.Context, req Request) (Result, error)

type HTTPFallback ¶

type HTTPFallback struct{}

HTTPFallback is the last resort: it takes any http(s) link that nothing else managed to fetch and simply asks the engine to download it. This is what catches a plain file whose URL carries no extension — a shape the strict Direct rule cannot recognise, and which a media extractor cannot handle either. It sits at the bottom of the priority list, so it only ever runs after every real backend has had its turn.

func (HTTPFallback) Info() Info

func (HTTPFallback) Match(raw string) bool

func (HTTPFallback) Resolve(_ context.Context, req Request) (Result, error)

type HostCache ¶

type HostCache struct {
	// Fetch asks the live source for a fresh host set. Required; a nil Fetch
	// makes Refresh a no-op rather than a panic, which is what lets a
	// zero-value HostCache with only Load set still answer Hosts() from disk.
	Fetch func(ctx context.Context) (map[string]bool, error)
	// Load seeds the cache before its first use, so a process that restarts
	// mid-outage still serves yesterday's list rather than an empty one for
	// however long the source stays down. ok is false for "nothing was ever
	// persisted", which is not the same as an empty set. Nil means "nothing
	// to seed from".
	Load func() (hosts map[string]bool, fetchedAt time.Time, ok bool)
	// Save is called after every SUCCESSFUL refresh, never after a failed
	// one - a failed fetch has nothing new worth writing down, and rewriting
	// the same bytes back on every failed retry would only wear the disk for
	// no reason. Nil means "keep it in memory only".
	Save func(hosts map[string]bool, fetchedAt time.Time)
	// contains filtered or unexported fields
}

HostCache is a supported-host set that refreshes itself from a live source and never lets a failed refresh empty what it is already holding.

THE FAILURE MODE THIS EXISTS FOR: a Resolver's Match reads a host set built from this cache, and an empty set reads as "this service supports nothing" - see debrid.HostInSet and the identical helper in torbox and ytdlp, all of which treat a nil or empty map as "matches nothing", on purpose, for a service that genuinely has no hosts configured. Before this existed, whatever asked a service for its host list and got a transient error (a timeout, a 500, a rate limit) handed that same empty result straight to Registry.Register, and the resolver kept its slot in the registry while silently matching nothing - not until the next successful refresh, but until the process restarted and asked again from a clean slate. So a failed Refresh leaves Hosts() exactly as it was, and only FetchedAt and LastError move.

It is deliberately unopinionated about persistence: Load and Save are nil by default, which makes the type pure and trivially testable with nothing but a fake Fetch func, and a caller that wants a refresh to survive a restart wires real storage in once, at construction.

func (c *HostCache) FetchedAt() time.Time

func (c *HostCache) Hosts() map[string]bool

func (c *HostCache) LastError() error

func (c *HostCache) Refresh(ctx context.Context) error

type HostCapper ¶

type HostCapper interface {
	HostCap(host string) int
}

HostCapper is the optional other half of a resolver that can state a ceiling on how many chunks one download against a given host may safely open - the per-host fact a multihoster account sometimes has an opinion about (see internal/resolver/debrid.HostLimiter), read by app.connsFor as one more ceiling in its chain.

Kept off Resolver itself for the same reason Checker is: a resolver with nothing to say about a host must not be forced to grow a method that invents a number. 0 means "no opinion" - read by the caller exactly like every other absent ceiling in connsFor, never as "zero connections".

type Info ¶

type Info struct {
	ID   string `json:"id"`
	Prio int    `json:"prio"`
}

Info identifies a resolver and sets its routing priority (higher wins).

Tagged for JSON because PriorityFor exists to make that order visible to a user, not only to act on internally - see Registry.PriorityFor.

type Registry ¶

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

Registry keeps resolvers ordered by descending priority. It is safe for concurrent use: adding an account rebuilds the routing table while downloads are running.

func NewRegistry() *Registry

func (r *Registry) All(url string) []Resolver

func (r *Registry) AllInfo() []Info

func (r *Registry) For(url string) Resolver

func (r *Registry) IDs() []string

func (r *Registry) PriorityFor(host string) []Info

func (r *Registry) Register(res Resolver)

func (r *Registry) Unregister(id string)

type Request ¶

type Request struct {
	URL string
}

Request is what the resolver is asked to resolve.

type Resolver ¶

type Resolver interface {
	Info() Info
	Match(url string) bool
	Resolve(ctx context.Context, req Request) (Result, error)
}

Resolver turns a link into a downloadable Result.

type Result ¶

type Result struct {
	Name        string
	DirectURL   string
	Headers     map[string]string
	Size        int64
	Connections int
}

Result is a concrete download target the engine can fetch.