sulthan
b517858619
Add series.site_completed_at (epoch-ms, default 0): the durable answer #168's predicates compute. checkOne writes it after the successful read on the zero/non-zero transition only, so a Series still completed keeps its original stamp (the age #170 prints is 'since the Site first said so'), one that stopped is zeroed, one that became completed is stamped. The due query projects the column, so the transition is a field comparison on the snapshot checkOne already holds. Refused, unreachable and errored reads reach nothing (AC4 is placement, not a guard); the write sits before the no-chapter and unchanged-number returns, so a completed page whose chapter did not change still writes. Store failure logs and carries on — the outcome word never changes. Series-level like Latest Chapter: a bookmark's updated_at is never touched. #170 is the surface; nothing reads the column yet.
91 lines
3.7 KiB
Go
91 lines
3.7 KiB
Go
package latest
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
)
|
|
|
|
// seriesRead carries the facts the poll and the acquirer both extract from a
|
|
// series page. Persistence, stamps and scheduling stay with the callers, so
|
|
// the policies that keep the two flows distinct (stamp order, rests) are not
|
|
// swallowed by the module.
|
|
type seriesRead struct {
|
|
Latest latestChapter
|
|
HasLatest bool
|
|
Cover string
|
|
HasCover bool
|
|
// SiteCompleted is whether the Site's own completed value was on the page.
|
|
// A challenge body and a redesign both read false — an absent hint, never
|
|
// a claim (issue #168).
|
|
SiteCompleted bool
|
|
// BodyLen is the fetched body's length, surfaced because the no-chapter
|
|
// log uses it to tell a markup change from a body the size cap cut short.
|
|
BodyLen int
|
|
}
|
|
|
|
// errNotFetchable and errNoFetcher separate the gate and the route from fetch
|
|
// failures so each caller keeps its own distinct log line for all three.
|
|
// errChallengeHeld (browser.go) is the outcome of a Site that answered with
|
|
// its interstitial — status 403 (cf-mitigated) or a challenge page body — and
|
|
// is how a Lane tells a refusal from an ordinary failure (issue #100).
|
|
// errNotFound marks any other 4xx: the page is gone — a fact the owner can act
|
|
// on — as distinct from a Site or database that is merely unwell (issue #164).
|
|
var (
|
|
errNotFetchable = errors.New("series url not fetchable")
|
|
errNoFetcher = errors.New("no fetcher for site")
|
|
errNotFound = errors.New("series page not found")
|
|
)
|
|
|
|
// readSeriesPage performs the series-page read the poll and the acquirer have
|
|
// in common: gate the address, choose the route, fetch the page, extract the
|
|
// Latest Chapter, the Cover address and the Site's completed value. It
|
|
// persists nothing and stamps nothing.
|
|
//
|
|
// series_url arrives in a client-supplied PUT body (PUT /bookmarks/{key}
|
|
// accepts any string), so the gate is not an optimisation against burning a
|
|
// request on an unknown site: without it, the server would issue a GET from
|
|
// its own network position to whatever URL a token-holder writes, including
|
|
// link-local/internal addresses or non-https schemes.
|
|
func readSeriesPage(ctx context.Context, site, seriesURL string, browser, tls Fetcher) (seriesRead, error) {
|
|
if !FetchableSeriesURL(site, seriesURL) {
|
|
return seriesRead{}, fmt.Errorf("%w: site=%q url=%q", errNotFetchable, site, seriesURL)
|
|
}
|
|
f := fetcherFor(site, browser, tls)
|
|
if f == nil {
|
|
return seriesRead{}, fmt.Errorf("%w: site %q", errNoFetcher, site)
|
|
}
|
|
body, status, err := f.Get(ctx, seriesURL)
|
|
if err != nil {
|
|
return seriesRead{}, fmt.Errorf("fetch %s: %w", seriesURL, err)
|
|
}
|
|
if status == 403 {
|
|
// Cloudflare's challenge response for these Sites (cf-mitigated). The
|
|
// browser fetcher returns exactly this on a held interstitial, and a
|
|
// plain-TLS 403 means the same: the Site is refusing.
|
|
return seriesRead{}, fmt.Errorf("%w: fetch %s: status %d", errChallengeHeld, seriesURL, status)
|
|
}
|
|
if status != 200 {
|
|
if status >= 400 && status < 500 {
|
|
return seriesRead{}, fmt.Errorf("%w: fetch %s: status %d", errNotFound, seriesURL, status)
|
|
}
|
|
return seriesRead{}, fmt.Errorf("fetch %s: status %d", seriesURL, status)
|
|
}
|
|
if isInterstitial(body) {
|
|
// A 200 that is the challenge page, not the payload: the TLS route can
|
|
// receive this where the browser would have kept re-reading. Same
|
|
// refusal as the 403.
|
|
return seriesRead{}, fmt.Errorf("%w: fetch %s: interstitial body", errChallengeHeld, seriesURL)
|
|
}
|
|
latest, hasLatest := latestChapterFrom(site, seriesURL, body)
|
|
cover, hasCover := coverFrom(site, seriesURL, body)
|
|
return seriesRead{
|
|
Latest: latest,
|
|
HasLatest: hasLatest,
|
|
Cover: cover,
|
|
HasCover: hasCover,
|
|
SiteCompleted: siteCompletedFrom(site, seriesURL, body),
|
|
BodyLen: len(body),
|
|
}, nil
|
|
}
|