feat: extract versioned YouTube service adapter
Wire pure Player parsing and strict qualification planning through a compiled-in kind/version registry. Fail closed before discovery requests when the required module is absent or mismatched. Require sealed module-bound v2 evidence for new writes while preserving fresh trusted v1 apply eligibility and historical rollback. Keep legacy SOCKS5h routing, separate suffix/asset policy and public configuration unchanged; generic controller cutover and field acceptance remain pending. Co-authored-by: GPT-6 <gpt-6@openai.com>
This commit is contained in:
1 parent
d324b4137b
commit
f4853173b3
21 files changed
+1176
-74
No files matched your search
@@ -9,6 +9,8 @@ import (
|
||||
"math"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"zapret-autotune/internal/adapter/youtube"
|
||||
)
|
||||
|
||||
// Additive only: old proposals are not independently qualified candidates.
|
||||
@@ -351,6 +353,7 @@ type GooglevideoHostProof struct {
|
||||
}
|
||||
|
||||
type GooglevideoQualificationProof struct {
|
||||
Adapter *youtube.Binding `json:"adapter,omitempty"`
|
||||
Version int `json:"version"`
|
||||
Mode QualificationMode `json:"mode"`
|
||||
SourceKind string `json:"source_kind"`
|
||||
@@ -371,7 +374,25 @@ func (p GooglevideoQualificationProof) validate(c storedCandidate) error {
|
||||
}
|
||||
|
||||
func (p GooglevideoQualificationProof) validateStored(c storedCandidate) error {
|
||||
if p.Version != 1 || p.Mode != c.Mode || p.Args != c.Args || len(p.Hosts) != len(c.Endpoints) || len(p.Hosts) < 3 {
|
||||
// Missing binding is explicitly the immutable legacy YouTube v1 policy,
|
||||
// never the current registry default. Retain historical reconstruction.
|
||||
if p.Version == 1 {
|
||||
if p.Adapter != nil {
|
||||
return fmt.Errorf("legacy proof cannot carry adapter binding")
|
||||
}
|
||||
} else {
|
||||
if p.Mode != QualificationAdaptive || p.Adapter == nil {
|
||||
return fmt.Errorf("version-bound adaptive proof required")
|
||||
}
|
||||
module, err := lookupServiceAdapter(p.Adapter.Kind, p.Adapter.Version)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if *p.Adapter != module.Binding() {
|
||||
return fmt.Errorf("adapter policy mismatch")
|
||||
}
|
||||
}
|
||||
if (p.Version != 1 && p.Version != 2) || p.Mode != c.Mode || p.Args != c.Args || len(p.Hosts) != len(c.Endpoints) || len(p.Hosts) < 3 {
|
||||
return fmt.Errorf("invalid representative proof definition")
|
||||
}
|
||||
if (p.Mode == QualificationCold && p.SourceKind != "media-range") || (p.Mode == QualificationAdaptive && p.SourceKind != NativeCircularPostWarmup) || (p.Mode != QualificationCold && p.Mode != QualificationAdaptive) {
|
||||
@@ -380,7 +401,7 @@ func (p GooglevideoQualificationProof) validateStored(c storedCandidate) error {
|
||||
if err := (&candidate{Args: p.Args}).validateArgs(); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateGooglevideoHosts(c.Endpoints); err != nil {
|
||||
if err := validateLegacyYoutubeV1Hosts(c.Endpoints); err != nil {
|
||||
return err
|
||||
}
|
||||
if p.Mode == QualificationCold && p.Attestation != nil {
|
||||
@@ -494,7 +515,9 @@ func validateAdaptiveGooglevideoEvidence(db *sql.DB, c storedCandidate, fresh bo
|
||||
// One transactional insert, no cold candidate_evidence summaries. A private
|
||||
// producer seal is required as well as valid DTO facts and stored definition.
|
||||
func saveAdaptiveGooglevideoEvidence(tx *sql.Tx, id int64, proof GooglevideoQualificationProof) error {
|
||||
if proof.producerSeal == nil || *proof.producerSeal != googlevideoProofSeal(proof) {
|
||||
// Existing trusted v1 rows retain their original read/apply contract. Only
|
||||
// this new-write boundary requires the version-bound producer protocol.
|
||||
if proof.Version != 2 || proof.producerSeal == nil || *proof.producerSeal != googlevideoProofSeal(proof) {
|
||||
return fmt.Errorf("completed owned collector attestation required")
|
||||
}
|
||||
var c storedCandidate
|
||||
|
||||
@@ -148,6 +148,9 @@ func discoverYoutube(args []string, stdout, stderr io.Writer, runner playerRunne
|
||||
}
|
||||
|
||||
func requestPlayer(videoID, proxy string, runner playerRunner) ([]byte, error) {
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
payload, _ := json.Marshal(map[string]interface{}{
|
||||
"videoId": videoID,
|
||||
"context": map[string]interface{}{"client": map[string]interface{}{
|
||||
|
||||
@@ -44,6 +44,10 @@ func googlevideoProposal(flags []string, stdout, stderr io.Writer, discover play
|
||||
fmt.Fprintln(stderr, "error: tune googlevideo", err)
|
||||
return 2
|
||||
}
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
fmt.Fprintln(stderr, "error: tune googlevideo", err)
|
||||
return 1
|
||||
}
|
||||
started := time.Now()
|
||||
db, err := openStore(databasePath())
|
||||
if err != nil {
|
||||
|
||||
@@ -71,6 +71,9 @@ type managedServiceInventory struct {
|
||||
func managedServiceResources(cfg healthConfig, player func(context.Context) ([]byte, error), page playerRunner) func(context.Context) (managedServiceInventory, error) {
|
||||
return func(ctx context.Context) (managedServiceInventory, error) {
|
||||
i := managedServiceInventory{images: make(map[string]string), proxy: cfg.SOCKSProxy, runner: runResourceCurl}
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return i, err
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return i, managedRecoveryContextError(ctx, err)
|
||||
}
|
||||
@@ -105,6 +108,9 @@ func managedServiceResources(cfg healthConfig, player func(context.Context) ([]b
|
||||
}
|
||||
i.media, _, err = playerMediaResource(body)
|
||||
if err != nil {
|
||||
if errors.Is(err, errServiceAdapterUnavailable) {
|
||||
return i, err
|
||||
}
|
||||
i.resourceErr = &managedResourceFailure{"media", "unknown", err}
|
||||
}
|
||||
for attempt := 0; attempt < 2; attempt++ {
|
||||
@@ -152,6 +158,9 @@ func managedServiceResources(cfg healthConfig, player func(context.Context) ([]b
|
||||
|
||||
func managedServiceHealth(proxy string, front func(context.Context) (string, error), inventory func(context.Context) (managedServiceInventory, error), runner subprocessRunner) func(context.Context) (string, error) {
|
||||
return func(ctx context.Context) (string, error) {
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return "DEGRADED", err
|
||||
}
|
||||
status, err := front(ctx)
|
||||
if err != nil || status != "OK" {
|
||||
return "DEGRADED", &managedResourceFailure{"front", managedFrontendHost, err}
|
||||
|
||||
@@ -597,6 +597,9 @@ func managedPrestartReconcile(m *managedTransaction, d managedDeps) (err error)
|
||||
var errManagedScopeUnresolved = errors.New("managed deployment policy unresolved; explicit reconcile or fresh managed state required")
|
||||
|
||||
func managedActivate(m *managedTransaction, d managedDeps, ids []int64, expected map[int64]string, scopes ...GooglevideoScope) error {
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return err
|
||||
}
|
||||
info, err := os.Stat(d.script)
|
||||
if err != nil || !info.Mode().IsRegular() || info.Mode().Perm()&0111 == 0 {
|
||||
return fmt.Errorf("target zapret daemon init executable unavailable")
|
||||
@@ -606,6 +609,9 @@ func managedActivate(m *managedTransaction, d managedDeps, ids []int64, expected
|
||||
return err
|
||||
}
|
||||
m.Health = func() (string, error) {
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return "", err
|
||||
}
|
||||
portText, _ := d.lookup("SOCKS_PORT")
|
||||
port, err := strconv.Atoi(portText)
|
||||
if err != nil {
|
||||
|
||||
@@ -86,6 +86,9 @@ func managedExperimentalRequest(dir string, consume bool, apply func() error) er
|
||||
// Runs before the PID-1-owned monitor starts; never races a recovery worker.
|
||||
// A real Player-discovered identity is saved WITHOUT cold/adaptive evidence.
|
||||
func managedExperimentalSuffix(m *managedTransaction, d managedDeps) error {
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return err
|
||||
}
|
||||
singleton, err := acquireManagedMonitorSingleton(d)
|
||||
if err != nil {
|
||||
return err
|
||||
|
||||
@@ -179,7 +179,7 @@ func TestExperimentalPromotionRequiresRepresentativeOwnedProof(t *testing.T) {
|
||||
}
|
||||
assertActiveCandidates(t, d.transaction, d.db, []int64{front, thumb, avatar, id})
|
||||
p, err := readGooglevideoProof(d.db, id)
|
||||
if err != nil || p.Version != 1 || len(p.Hosts) != 3 {
|
||||
if err != nil || p.Version != 2 || p.Adapter == nil || len(p.Hosts) != 3 {
|
||||
t.Fatal(p, err)
|
||||
}
|
||||
c, err := readStrategyCandidate(d.db, experiment)
|
||||
|
||||
@@ -5,9 +5,10 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"zapret-autotune/internal/adapter/youtube"
|
||||
)
|
||||
|
||||
// Ordinary unresolved state, not a target/ownership guard failure.
|
||||
@@ -28,7 +29,7 @@ const managedGooglevideoDiscoveryTimeout = 3 * time.Minute
|
||||
|
||||
// Three hosts each need up to 120s warmup + six 35s transfers. Leave margin
|
||||
// for daemon lifecycle as well; short-lived URLs are refetched, never rewritten.
|
||||
const managedGooglevideoSampleTTL = 20 * time.Minute
|
||||
const managedGooglevideoSampleTTL = youtube.InventoryTTL
|
||||
|
||||
func freshGooglevideoSample(r mediaResource) bool {
|
||||
// The same exact GGC hostname syntax as the representative gate; reject bad
|
||||
@@ -37,13 +38,10 @@ func freshGooglevideoSample(r mediaResource) bool {
|
||||
if !ok || !strings.HasSuffix(r.host, ".googlevideo.com") || !validDomain(r.host) || r.host != strings.ToLower(r.host) || root == "" || len(prefix) < 3 || !strings.HasPrefix(prefix, "rr") || strings.Trim(prefix[2:], "0123456789") != "" {
|
||||
return false
|
||||
}
|
||||
u, err := privateResourceURL(r.url, r.host)
|
||||
if err != nil || u.Path != "/videoplayback" || (r.kind != "video/mp4" && r.kind != "audio/mp4") {
|
||||
if _, err := privateResourceURL(r.url, r.host); err != nil {
|
||||
return false
|
||||
}
|
||||
q := u.Query()
|
||||
expires, err := strconv.ParseInt(q.Get("expire"), 10, 64)
|
||||
return err == nil && expires > time.Now().Add(managedGooglevideoSampleTTL).Unix() && (q.Get("sig") != "" || q.Get("signature") != "" || q.Get("lsig") != "")
|
||||
return youtube.SignedSampleFresh(youtube.Resource{URL: r.url, Host: r.host, Kind: r.kind}, time.Now(), managedGooglevideoSampleTTL)
|
||||
}
|
||||
|
||||
// Choose exactly three actual hosts passing the unchanged representative gate.
|
||||
@@ -70,6 +68,9 @@ func representativeGooglevideoSamples(byHost map[string]mediaResource) []mediaRe
|
||||
func managedGooglevideoSamples(ids []string, request func(context.Context, string) ([]byte, error)) func(context.Context) ([]mediaResource, error) {
|
||||
ids = append([]string(nil), ids...)
|
||||
return func(ctx context.Context) ([]mediaResource, error) {
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(ids) == 0 || len(ids) > 5 || request == nil {
|
||||
return nil, &managedRecoveryFatal{Err: errors.New("invalid sample collector configuration")}
|
||||
}
|
||||
@@ -108,6 +109,9 @@ func managedGooglevideoSamples(ids []string, request func(context.Context, strin
|
||||
}
|
||||
r, _, err := playerMediaResource(body)
|
||||
if err != nil {
|
||||
if errors.Is(err, errServiceAdapterUnavailable) {
|
||||
return nil, err
|
||||
}
|
||||
stats.Unavailable++
|
||||
continue
|
||||
} // Missing/SABR is unknown, never fabricated.
|
||||
|
||||
@@ -9,9 +9,10 @@ import (
|
||||
"os"
|
||||
"os/exec"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"zapret-autotune/internal/adapter/youtube"
|
||||
)
|
||||
|
||||
// ponytail: one audited composite only. New native variants need an explicit
|
||||
@@ -93,45 +94,47 @@ func newManagedGooglevideoVerifier(target managedDeps) func(context.Context, sto
|
||||
}
|
||||
|
||||
func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCandidate, resources []mediaResource) (GooglevideoQualificationProof, error) {
|
||||
p := GooglevideoQualificationProof{Version: 1, Mode: QualificationAdaptive, SourceKind: NativeCircularPostWarmup, Args: c.Args}
|
||||
p := GooglevideoQualificationProof{Version: 2, Mode: QualificationAdaptive, SourceKind: NativeCircularPostWarmup, Args: c.Args}
|
||||
if c.Group != "googlevideo" || c.Mode != QualificationAdaptive {
|
||||
return p, errors.New("adaptive googlevideo definition required")
|
||||
}
|
||||
if err := validateNativeGooglevideoArgs(c.Args); err != nil {
|
||||
return p, err
|
||||
}
|
||||
module, err := requiredYoutubeAdapter()
|
||||
if err != nil {
|
||||
return p, err
|
||||
}
|
||||
binding := module.Binding()
|
||||
p.Adapter = &binding
|
||||
byHost := map[string]mediaResource{}
|
||||
var samples []youtube.Resource
|
||||
for _, resource := range resources {
|
||||
u, err := privateResourceURL(resource.url, resource.host)
|
||||
if err != nil || u.Path != "/videoplayback" || (resource.kind != "video/mp4" && resource.kind != "audio/mp4") {
|
||||
return p, errGooglevideoInsufficientSamples
|
||||
}
|
||||
q := u.Query()
|
||||
expires, err := strconv.ParseInt(q.Get("expire"), 10, 64)
|
||||
if err != nil || expires <= time.Now().Unix()+120 || (q.Get("sig") == "" && q.Get("signature") == "" && q.Get("lsig") == "") {
|
||||
if _, err := privateResourceURL(resource.url, resource.host); err != nil {
|
||||
return p, errGooglevideoInsufficientSamples
|
||||
}
|
||||
byHost[resource.host] = resource
|
||||
samples = append(samples, youtube.Resource{URL: resource.url, Host: resource.host, Kind: resource.kind})
|
||||
}
|
||||
// Validate representative host diversity using the shared gate before capture.
|
||||
for _, host := range c.Endpoints {
|
||||
if _, ok := byHost[host]; !ok {
|
||||
return p, errGooglevideoInsufficientSamples
|
||||
}
|
||||
p.Hosts = append(p.Hosts, GooglevideoHostProof{Host: host})
|
||||
}
|
||||
if err := validateGooglevideoHosts(c.Endpoints); err != nil {
|
||||
if validateGooglevideoHosts(c.Endpoints) != nil {
|
||||
return p, errGooglevideoInsufficientSamples
|
||||
}
|
||||
err := r.withOwnedWorker(ctx, c.Endpoints, c.Args, func(probeCtx context.Context) error {
|
||||
plan, err := module.PlanQualification(c.Endpoints, samples, time.Now())
|
||||
if err != nil {
|
||||
return p, errGooglevideoInsufficientSamples
|
||||
}
|
||||
for _, host := range plan.Hosts {
|
||||
p.Hosts = append(p.Hosts, GooglevideoHostProof{Host: host})
|
||||
}
|
||||
err = r.withOwnedWorker(ctx, c.Endpoints, c.Args, func(probeCtx context.Context) error {
|
||||
for i := range p.Hosts {
|
||||
h := &p.Hosts[i]
|
||||
h.WarmupLimit = 10
|
||||
h.WarmupLimit = plan.WarmupLimit
|
||||
start := time.Now()
|
||||
warmCtx, cancel := context.WithTimeout(probeCtx, 120*time.Second)
|
||||
warmCtx, cancel := context.WithTimeout(probeCtx, plan.WarmupTimeout)
|
||||
learned := map[string]bool{}
|
||||
for h.WarmupAttempts < h.WarmupLimit && len(learned) < 2 && warmCtx.Err() == nil {
|
||||
protocol := []string{"tls12", "tls13"}[h.WarmupAttempts%2]
|
||||
for h.WarmupAttempts < h.WarmupLimit && len(learned) < len(plan.Protocols) && warmCtx.Err() == nil {
|
||||
protocol := plan.Protocols[h.WarmupAttempts%len(plan.Protocols)]
|
||||
h.WarmupAttempts++
|
||||
_, pass, err := collectMediaTransfer(warmCtx, r.proxy, byHost[h.Host], protocol, r.curl)
|
||||
if err != nil {
|
||||
@@ -140,7 +143,7 @@ func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCand
|
||||
cancel()
|
||||
return err
|
||||
}
|
||||
} else if pass.Bytes < 1024 {
|
||||
} else if pass.Bytes < plan.MinBytes {
|
||||
h.WarmupFailures++
|
||||
} else {
|
||||
learned[protocol] = true
|
||||
@@ -151,11 +154,11 @@ func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCand
|
||||
if probeCtx.Err() != nil {
|
||||
return probeCtx.Err()
|
||||
}
|
||||
if len(learned) != 2 || h.WarmupMS > 120000 {
|
||||
if len(learned) != len(plan.Protocols) || h.WarmupMS > float64(plan.WarmupTimeout/time.Millisecond) {
|
||||
return errCandidateNonpass
|
||||
}
|
||||
for _, protocol := range []string{"tls12", "tls13"} {
|
||||
for n := 0; n < 3; n++ {
|
||||
for _, protocol := range plan.Protocols {
|
||||
for n := 0; n < plan.Samples; n++ {
|
||||
_, pass, err := collectMediaTransfer(probeCtx, r.proxy, byHost[h.Host], protocol, r.curl)
|
||||
if err != nil {
|
||||
if managedGooglevideoTransferNonpass(err) {
|
||||
@@ -163,7 +166,7 @@ func (r managedAssetRuntime) verifyGooglevideo(ctx context.Context, c storedCand
|
||||
}
|
||||
return err
|
||||
}
|
||||
if pass.Bytes < 1024 {
|
||||
if pass.Bytes < plan.MinBytes {
|
||||
return errCandidateNonpass
|
||||
}
|
||||
h.Passes = append(h.Passes, pass)
|
||||
@@ -239,16 +242,28 @@ func managedResourceTransferNonpass(err error, metadata, image bool) bool {
|
||||
}
|
||||
|
||||
func validateGooglevideoHosts(hosts []string) error {
|
||||
seen, roots, prefixes := map[string]bool{}, map[string]bool{}, map[string]bool{}
|
||||
for _, host := range hosts {
|
||||
prefix, root, ok := strings.Cut(strings.TrimSuffix(host, ".googlevideo.com"), "---sn-")
|
||||
if !ok || !strings.HasSuffix(host, ".googlevideo.com") || !validDomain(host) || host != strings.ToLower(host) || seen[host] || root == "" || len(prefix) < 3 || !strings.HasPrefix(prefix, "rr") || strings.Trim(prefix[2:], "0123456789") != "" {
|
||||
if !validDomain(host) {
|
||||
return errGooglevideoInsufficientSamples
|
||||
}
|
||||
seen[host], roots[strings.Split(root, "-")[0]], prefixes[prefix] = true, true, true
|
||||
}
|
||||
if len(hosts) < 3 || len(roots) < 2 || len(prefixes) < 2 {
|
||||
module, err := requiredYoutubeAdapter()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if module.ValidateHosts(hosts) != nil {
|
||||
return errGooglevideoInsufficientSamples
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Historical v1 reconstruction must not depend on a future registry default.
|
||||
// This pinned contract remains available even when the execution module is absent.
|
||||
func validateLegacyYoutubeV1Hosts(hosts []string) error {
|
||||
for _, host := range hosts {
|
||||
if !validDomain(host) {
|
||||
return errGooglevideoInsufficientSamples
|
||||
}
|
||||
}
|
||||
return (youtube.Module{}).ValidateHosts(hosts)
|
||||
}
|
||||
@@ -47,6 +47,9 @@ type managedRecoveryDeps struct {
|
||||
// The injected command runner receives only fixed script/argv from orchestration.
|
||||
func managedRecoveryDependencies(target managedDeps, db *sql.DB, scan cacheScan, check cacheCheck, run func(context.Context, string, ...string) error) (managedRecoveryDeps, error) {
|
||||
d := managedRecoveryDeps{db: db, scan: scan, check: check, run: run}
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return d, err
|
||||
}
|
||||
if target.lookup == nil || target.player == nil || db == nil || scan == nil || check == nil || run == nil {
|
||||
return d, fmt.Errorf("complete target-local recovery adapter dependencies required")
|
||||
}
|
||||
@@ -59,6 +62,9 @@ func managedRecoveryDependencies(target managedDeps, db *sql.DB, scan cacheScan,
|
||||
}
|
||||
d.transaction = &managedTransaction{Dir: target.directory, Name: "config"}
|
||||
requestVideo := func(ctx context.Context, videoID string) ([]byte, error) {
|
||||
if _, err := requiredYoutubeAdapter(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
@@ -190,39 +190,17 @@ type mediaCapability struct {
|
||||
|
||||
// SABR is deliberately unknown/not supported, never fabricated as readiness.
|
||||
func playerMediaResource(body []byte) (mediaResource, mediaCapability, error) {
|
||||
var p struct {
|
||||
PlayabilityStatus struct {
|
||||
Status string `json:"status"`
|
||||
} `json:"playabilityStatus"`
|
||||
StreamingData struct {
|
||||
Formats []struct {
|
||||
URL string `json:"url"`
|
||||
MimeType string `json:"mimeType"`
|
||||
} `json:"formats"`
|
||||
AdaptiveFormats []struct {
|
||||
URL string `json:"url"`
|
||||
MimeType string `json:"mimeType"`
|
||||
} `json:"adaptiveFormats"`
|
||||
} `json:"streamingData"`
|
||||
module, err := requiredYoutubeAdapter()
|
||||
if err != nil {
|
||||
return mediaResource{}, mediaCapability{}, err
|
||||
}
|
||||
if len(body) > playerResponseLimit || json.Unmarshal(body, &p) != nil || p.PlayabilityStatus.Status != "OK" {
|
||||
return mediaResource{}, mediaCapability{}, errors.New("invalid playable metadata")
|
||||
resources, err := module.DiscoverResponse(body)
|
||||
if err != nil {
|
||||
return mediaResource{}, mediaCapability{}, err
|
||||
}
|
||||
for _, f := range append(p.StreamingData.Formats, p.StreamingData.AdaptiveFormats...) {
|
||||
u, err := url.Parse(f.URL)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
host := u.Hostname()
|
||||
if !strings.HasSuffix(host, ".googlevideo.com") {
|
||||
continue
|
||||
}
|
||||
if _, err := privateResourceURL(f.URL, host); err != nil {
|
||||
continue
|
||||
}
|
||||
kind, _, err := mime.ParseMediaType(f.MimeType)
|
||||
if err == nil && (kind == "video/mp4" || kind == "audio/mp4") {
|
||||
return mediaResource{f.URL, host, kind}, mediaCapability{OrdinaryURL: true}, nil
|
||||
for _, r := range resources {
|
||||
if _, err := privateResourceURL(r.URL, r.Host); err == nil {
|
||||
return mediaResource{r.URL, r.Host, r.Kind}, mediaCapability{OrdinaryURL: true}, nil
|
||||
}
|
||||
}
|
||||
return mediaResource{}, mediaCapability{}, nil
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"sync"
|
||||
|
||||
"zapret-autotune/internal/adapter"
|
||||
"zapret-autotune/internal/adapter/youtube"
|
||||
)
|
||||
|
||||
// Trusted compiled-in dispatch, deliberately not a public config/plugin API.
|
||||
// An empty registry is a supported fail-closed seam; no HTTP fallback exists.
|
||||
type serviceAdapterKey struct {
|
||||
kind string
|
||||
version int
|
||||
}
|
||||
type serviceAdapterRegistry map[serviceAdapterKey]adapter.Module
|
||||
|
||||
var errServiceAdapterUnavailable = errors.New("required service adapter unavailable")
|
||||
|
||||
// The registry is immutable in production. The lock permits race-free test
|
||||
// replacement while request callbacks/owned lifecycle children are running.
|
||||
var serviceAdapters = struct {
|
||||
sync.RWMutex
|
||||
modules serviceAdapterRegistry
|
||||
}{modules: serviceAdapterRegistry{{youtube.Kind, youtube.Version}: youtube.Module{}}}
|
||||
|
||||
func requiredYoutubeAdapter() (adapter.Module, error) {
|
||||
serviceAdapters.RLock()
|
||||
m, err := serviceAdapters.modules.lookup(youtube.Kind, youtube.Version)
|
||||
serviceAdapters.RUnlock()
|
||||
if err != nil || m.Binding() != (youtube.Module{}).Binding() {
|
||||
return nil, &managedRecoveryFatal{Err: errServiceAdapterUnavailable}
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (r serviceAdapterRegistry) lookup(kind string, version int) (adapter.Module, error) {
|
||||
m, ok := r[serviceAdapterKey{kind, version}]
|
||||
if !ok || m == nil {
|
||||
return nil, errServiceAdapterUnavailable
|
||||
}
|
||||
b := m.Binding()
|
||||
if b.Kind != kind || b.Version != version {
|
||||
return nil, errServiceAdapterUnavailable
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func lookupServiceAdapter(kind string, version int) (adapter.Module, error) {
|
||||
serviceAdapters.RLock()
|
||||
defer serviceAdapters.RUnlock()
|
||||
return serviceAdapters.modules.lookup(kind, version)
|
||||
}
|
||||
@@ -0,0 +1,284 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"zapret-autotune/internal/adapter"
|
||||
"zapret-autotune/internal/adapter/youtube"
|
||||
)
|
||||
|
||||
func replaceServiceAdapters(t *testing.T, modules serviceAdapterRegistry) {
|
||||
t.Helper()
|
||||
serviceAdapters.Lock()
|
||||
previous := serviceAdapters.modules
|
||||
serviceAdapters.modules = modules
|
||||
serviceAdapters.Unlock()
|
||||
t.Cleanup(func() {
|
||||
serviceAdapters.Lock()
|
||||
serviceAdapters.modules = previous
|
||||
serviceAdapters.Unlock()
|
||||
})
|
||||
}
|
||||
|
||||
func TestServiceAdapterDispatchFailClosed(t *testing.T) {
|
||||
for _, key := range []serviceAdapterKey{{"unknown", 1}, {youtube.Kind, 0}, {youtube.Kind, 2}} {
|
||||
if _, err := lookupServiceAdapter(key.kind, key.version); err == nil {
|
||||
t.Fatal("unsupported adapter accepted")
|
||||
}
|
||||
}
|
||||
if _, err := (serviceAdapterRegistry{}).lookup(youtube.Kind, youtube.Version); err == nil {
|
||||
t.Fatal("absent adapter accepted")
|
||||
}
|
||||
replaceServiceAdapters(t, serviceAdapterRegistry{})
|
||||
if _, _, err := playerMediaResource([]byte(`{"playabilityStatus":{"status":"OK"}}`)); err == nil {
|
||||
t.Fatal("discovery bypassed registry")
|
||||
}
|
||||
r, c, resources, events := googlevideoRuntimeFixture(t)
|
||||
if _, err := r.verifyGooglevideo(context.Background(), c, resources); err == nil || len(*events) != 0 {
|
||||
t.Fatal("qualification bypassed registry")
|
||||
}
|
||||
}
|
||||
|
||||
type mismatchedServiceAdapter struct{ adapter.Module }
|
||||
|
||||
func (m mismatchedServiceAdapter) Binding() adapter.Binding {
|
||||
b := m.Module.Binding()
|
||||
b.Version++
|
||||
return b
|
||||
}
|
||||
|
||||
func TestServiceAdapterIdentityBeforeExecution(t *testing.T) {
|
||||
replaceServiceAdapters(t, serviceAdapterRegistry{{youtube.Kind, youtube.Version}: mismatchedServiceAdapter{youtube.Module{}}})
|
||||
r, c, resources, events := googlevideoRuntimeFixture(t)
|
||||
if _, err := r.verifyGooglevideo(context.Background(), c, resources); err == nil || len(*events) != 0 {
|
||||
t.Fatal("identity mismatch reached worker")
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceAdapterStoredProofRefusals(t *testing.T) {
|
||||
r, c, resources, _ := googlevideoRuntimeFixture(t)
|
||||
p, err := r.verifyGooglevideo(context.Background(), c, resources)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
db := testStore(t)
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer tx.Rollback()
|
||||
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := saveAdaptiveGooglevideoEvidence(tx, id, p); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
|
||||
for _, mode := range []string{"kind", "version", "digest", "missing", "unknown-proof", "downgrade", "attestation"} {
|
||||
t.Run(mode, func(t *testing.T) {
|
||||
raw, _ := json.Marshal(p)
|
||||
var proof GooglevideoQualificationProof
|
||||
if err := json.Unmarshal(raw, &proof); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
switch mode {
|
||||
case "kind":
|
||||
proof.Adapter.Kind = "unknown"
|
||||
case "version":
|
||||
proof.Adapter.Version++
|
||||
case "digest":
|
||||
proof.Adapter.PolicySHA256 = "changed"
|
||||
case "missing":
|
||||
proof.Adapter = nil
|
||||
case "unknown-proof":
|
||||
proof.Version = 3
|
||||
case "downgrade":
|
||||
proof.Version = 1
|
||||
case "attestation":
|
||||
proof.Attestation = nil
|
||||
}
|
||||
if proof.validateStored(c) == nil {
|
||||
t.Fatal("malformed proof reconstructed")
|
||||
}
|
||||
raw, _ = json.Marshal(proof)
|
||||
if _, err := db.Exec("UPDATE googlevideo_scope_evidence SET proof=? WHERE candidate_id=?", string(raw), id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
m, reloads := managedFixture(t)
|
||||
if err := m.Apply(db, []int64{front, id}, GooglevideoScopeSuffix); err == nil || *reloads != 0 {
|
||||
t.Fatal("invalid proof reached apply", err, *reloads)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceAdapterProofBoundary(t *testing.T) {
|
||||
r, c, resources, _ := googlevideoRuntimeFixture(t)
|
||||
p, err := r.verifyGooglevideo(context.Background(), c, resources)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if p.Version != 2 || p.Adapter == nil || *p.Adapter != (youtube.Module{}).Binding() {
|
||||
t.Fatal("missing module identity")
|
||||
}
|
||||
seal := googlevideoProofSeal(p)
|
||||
for _, mutate := range []func(){
|
||||
func() { p.Adapter.Kind = "unknown" },
|
||||
func() { p.Adapter.Version++ },
|
||||
func() { p.Adapter.PolicySHA256 = "changed" },
|
||||
} {
|
||||
original := *p.Adapter
|
||||
mutate()
|
||||
if p.validateStored(c) == nil || googlevideoProofSeal(p) == seal {
|
||||
t.Fatal("module boundary not bound to evidence")
|
||||
}
|
||||
*p.Adapter = original
|
||||
}
|
||||
// Reads retain the original v1 contract, including fresh apply eligibility.
|
||||
p.Version, p.Adapter = 1, nil
|
||||
raw, err := json.Marshal(p)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
legacy, err := decodeGooglevideoProof(string(raw))
|
||||
if err != nil || legacy.validateStored(c) != nil {
|
||||
t.Fatal("legacy reconstruction lost", err)
|
||||
}
|
||||
if legacy.validate(c) != nil {
|
||||
t.Fatal("fresh trusted legacy adaptive proof lost apply eligibility")
|
||||
}
|
||||
legacy.Attestation.CheckedAt = time.Now().Add(-25 * time.Hour)
|
||||
if legacy.validate(c) == nil {
|
||||
t.Fatal("expired legacy adaptive proof authorized new apply")
|
||||
}
|
||||
replaceServiceAdapters(t, serviceAdapterRegistry{})
|
||||
if legacy.validateStored(c) != nil {
|
||||
t.Fatal("historical reconstruction depends on current execution registry")
|
||||
}
|
||||
}
|
||||
|
||||
type changedPolicyServiceAdapter struct{ adapter.Module }
|
||||
|
||||
func (m changedPolicyServiceAdapter) Binding() adapter.Binding {
|
||||
b := m.Module.Binding()
|
||||
b.PolicySHA256 = "changed"
|
||||
return b
|
||||
}
|
||||
|
||||
func TestServiceAdapterDiscoveryPreflight(t *testing.T) {
|
||||
for _, mode := range []string{"missing", "version", "digest"} {
|
||||
t.Run(mode, func(t *testing.T) {
|
||||
modules := serviceAdapterRegistry{}
|
||||
if mode == "version" {
|
||||
modules[serviceAdapterKey{youtube.Kind, youtube.Version}] = mismatchedServiceAdapter{youtube.Module{}}
|
||||
}
|
||||
if mode == "digest" {
|
||||
modules[serviceAdapterKey{youtube.Kind, youtube.Version}] = changedPolicyServiceAdapter{youtube.Module{}}
|
||||
}
|
||||
calls := 0
|
||||
player := func(context.Context, []string, io.Writer, io.Writer) error { calls++; return nil }
|
||||
request := func(context.Context) ([]byte, error) { calls++; return nil, nil }
|
||||
target, _, _ := managedCLIFixture(t)
|
||||
target.player = player
|
||||
target.verifySOCKS = func(int) error { calls++; return nil }
|
||||
r, _, _ := recoveryFixture(t, false)
|
||||
bound, err := managedRecoveryDependencies(target, r.db, r.scan, r.check, r.run)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
calls = 0 // Construction guard is allowed before removing the module.
|
||||
replaceServiceAdapters(t, modules)
|
||||
cfg := healthConfig{VideoID: "dQw4w9WgXcQ", SOCKSProxy: "socks5://127.0.0.1:1080"}
|
||||
assertBlocked := func(err error) {
|
||||
t.Helper()
|
||||
var fatal *managedRecoveryFatal
|
||||
if !errors.Is(err, errServiceAdapterUnavailable) || !errors.As(err, &fatal) || errors.Is(err, errNoQualifiedStrategy) || errors.Is(err, errGooglevideoInsufficientSamples) || managedResourceTransferNonpass(err, true, true) {
|
||||
t.Fatal("adapter configuration became a retryable absence", err)
|
||||
}
|
||||
if calls != 0 {
|
||||
t.Fatal("preflight made network calls", calls)
|
||||
}
|
||||
}
|
||||
_, err = requestPlayer(cfg.VideoID, cfg.SOCKSProxy, player)
|
||||
assertBlocked(err)
|
||||
if managedResourceTransferNonpass(errors.Join(err, context.DeadlineExceeded), true, true) || managedRecoveryCooldown(errors.Join(err, errNoQualifiedStrategy), time.Minute) != time.Minute {
|
||||
t.Fatal("mixed fatal adapter failure became transfer-negative/2h absence")
|
||||
}
|
||||
_, err = bound.discover(context.Background())
|
||||
assertBlocked(err)
|
||||
_, err = bound.health(context.Background())
|
||||
assertBlocked(err)
|
||||
_, err = managedGooglevideoSamples([]string{cfg.VideoID}, func(ctx context.Context, _ string) ([]byte, error) { return request(ctx) })(context.Background())
|
||||
assertBlocked(err)
|
||||
inventory := managedServiceResources(cfg, request, player)
|
||||
_, err = inventory(context.Background())
|
||||
assertBlocked(err)
|
||||
_, err = managedServiceHealth(cfg.SOCKSProxy, func(context.Context) (string, error) { calls++; return "OK", nil }, inventory, func(context.Context, []string, io.Reader, io.Writer, io.Writer) error { calls++; return nil })(context.Background())
|
||||
assertBlocked(err)
|
||||
if code := discoverYoutube([]string{"--video-id", cfg.VideoID, "--proxy", cfg.SOCKSProxy}, io.Discard, io.Discard, player); code != 1 || calls != 0 {
|
||||
t.Fatal("legacy CLI bypassed preflight", code, calls)
|
||||
}
|
||||
_, err = managedRecoveryDependencies(target, r.db, r.scan, r.check, r.run)
|
||||
assertBlocked(err)
|
||||
assertBlocked(managedExperimentalSuffix(nil, managedDeps{}))
|
||||
assertBlocked(managedActivate(nil, managedDeps{}, nil, nil))
|
||||
for _, saved := range []bool{false, true} {
|
||||
code := googlevideoProposal([]string{"--video-id", cfg.VideoID, "--proxy", cfg.SOCKSProxy}, io.Discard, io.Discard, player, func(context.Context, string, string, io.Writer, io.Writer) (string, error) { calls++; return "", nil }, func(context.Context, string, string, string, string, io.Writer, io.Writer) error { calls++; return nil }, saved)
|
||||
if code != 1 || calls != 0 {
|
||||
t.Fatal("proposal pipeline bypassed preflight", code, calls)
|
||||
}
|
||||
}
|
||||
runtime, c, resources, events := googlevideoRuntimeFixture(t)
|
||||
_, err = runtime.verifyGooglevideo(context.Background(), c, resources)
|
||||
assertBlocked(err)
|
||||
if len(*events) != 0 {
|
||||
t.Fatal("preflight launched worker")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceAdapterLegacyNewWriteRefused(t *testing.T) {
|
||||
r, c, resources, _ := googlevideoRuntimeFixture(t)
|
||||
p, err := r.verifyGooglevideo(context.Background(), c, resources)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
p.Version, p.Adapter = 1, nil
|
||||
if p.validate(c) != nil {
|
||||
t.Fatal("trusted legacy read invalid")
|
||||
}
|
||||
// Even an internally constructed seal cannot authorize NEW v1 publication.
|
||||
seal := googlevideoProofSeal(p)
|
||||
p.producerSeal = &seal
|
||||
db := testStore(t)
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer tx.Rollback()
|
||||
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if saveAdaptiveGooglevideoEvidence(tx, id, p) == nil {
|
||||
t.Fatal("new sealed v1 write accepted")
|
||||
}
|
||||
raw, _ := json.Marshal(p)
|
||||
var dto GooglevideoQualificationProof
|
||||
if err := json.Unmarshal(raw, &dto); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if saveAdaptiveGooglevideoEvidence(tx, id, dto) == nil {
|
||||
t.Fatal("unsealed v1 DTO write accepted")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
package main
|
||||
|
||||
// Portable trusted-history fixtures: run unchanged on archived d324b41 too.
|
||||
// Direct SQL below models an existing trusted v1 database, not an import API.
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func legacyYoutubeV1Fixture(t *testing.T, db *sql.DB) (int64, GooglevideoQualificationProof) {
|
||||
t.Helper()
|
||||
r, c, resources, _ := googlevideoRuntimeFixture(t)
|
||||
p, err := r.verifyGooglevideo(context.Background(), c, resources)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
raw, _ := json.Marshal(p)
|
||||
var fields map[string]json.RawMessage
|
||||
if err := json.Unmarshal(raw, &fields); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
delete(fields, "adapter")
|
||||
fields["version"] = json.RawMessage(`1`)
|
||||
raw, _ = json.Marshal(fields)
|
||||
legacy, err := decodeGooglevideoProof(string(raw))
|
||||
if err != nil || legacy.validate(c) != nil {
|
||||
t.Fatal("trusted v1 contract invalid", err)
|
||||
}
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer tx.Rollback()
|
||||
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := tx.Exec("INSERT INTO googlevideo_scope_evidence(candidate_id,proof) VALUES (?,?)", id, string(raw)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return id, legacy
|
||||
}
|
||||
|
||||
func expireLegacyYoutubeV1(t *testing.T, db *sql.DB, id int64, proof GooglevideoQualificationProof) {
|
||||
t.Helper()
|
||||
proof.Attestation.CheckedAt = time.Now().Add(-25 * time.Hour)
|
||||
raw, _ := json.Marshal(proof)
|
||||
if _, err := db.Exec("UPDATE googlevideo_scope_evidence SET proof=? WHERE candidate_id=?", string(raw), id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyYoutubeV1FreshApplyEligibility(t *testing.T) {
|
||||
db := testStore(t)
|
||||
id, proof := legacyYoutubeV1Fixture(t, db)
|
||||
c, err := readStrategyCandidate(db, id)
|
||||
if err != nil || !c.Qualified {
|
||||
t.Fatal("fresh stored v1 lost qualification", err)
|
||||
}
|
||||
saved, err := listQualifiedCandidates(db, "googlevideo", 10)
|
||||
if err != nil || len(saved) != 1 || saved[0].ID != id {
|
||||
t.Fatal("fresh stored v1 disappeared from shortlist", err)
|
||||
}
|
||||
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
|
||||
ids := []int64{front, id} // Native suffix still does not require assets.
|
||||
m, reloads := managedFixture(t)
|
||||
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err != nil {
|
||||
t.Fatal("fresh v1 apply rejected", err)
|
||||
}
|
||||
config, err := m.read(m.Name)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
expireLegacyYoutubeV1(t, db, id, proof)
|
||||
c, err = readStrategyCandidate(db, id)
|
||||
if err != nil || c.Qualified {
|
||||
t.Fatal("expired v1 retained fresh qualification", err)
|
||||
}
|
||||
before := *reloads
|
||||
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err == nil || *reloads != before {
|
||||
t.Fatal("expired v1 activated")
|
||||
}
|
||||
rendered, err := renderStoredManagedConfigScope(db, ids, GooglevideoScopeSuffix)
|
||||
if err != nil || !bytes.Equal(config, rendered) {
|
||||
t.Fatal("expired historical reconstruction changed", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyYoutubeV1PreparedRollback(t *testing.T) {
|
||||
for _, point := range []string{"staged", "backup", "prepared", "replaced", "reloaded", "healthy"} {
|
||||
t.Run(point, func(t *testing.T) {
|
||||
db := testStore(t)
|
||||
id, proof := legacyYoutubeV1Fixture(t, db)
|
||||
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
|
||||
ids := []int64{front, id}
|
||||
m, reloads := managedFixture(t)
|
||||
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
before, err := m.load()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
journal, err := m.read(managedJournalName)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
config, err := m.read(m.Name)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
nextFront := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=fake", true)
|
||||
m.fault = func(stage string) error {
|
||||
if stage == point {
|
||||
return errors.New("fixture crash")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
if err := m.Apply(db, []int64{nextFront, id}, GooglevideoScopeSuffix); err == nil {
|
||||
t.Fatal("fault missed")
|
||||
}
|
||||
if point != "staged" {
|
||||
backup, err := m.read(managedBackupName)
|
||||
if err != nil || !bytes.Equal(backup, config) {
|
||||
t.Fatal("legacy backup changed", err)
|
||||
}
|
||||
}
|
||||
expireLegacyYoutubeV1(t, db, id, proof)
|
||||
m.fault = nil
|
||||
priorReloads := *reloads
|
||||
if err := m.Reconcile(db); err != nil {
|
||||
t.Fatal("expired v1 prepared recovery failed", err)
|
||||
}
|
||||
after, err := m.load()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
wantGeneration, wantReloads := before.Generation+1, priorReloads+1
|
||||
if point == "staged" || point == "backup" {
|
||||
wantGeneration, wantReloads = before.Generation, priorReloads
|
||||
}
|
||||
if after.State != "committed" || after.Hash != before.Hash || after.Scope != before.Scope || !reflect.DeepEqual(after.Candidates, before.Candidates) || len(after.PendingCandidates) != 0 || after.PendingScope != "" || after.Generation != wantGeneration || *reloads != wantReloads {
|
||||
t.Fatal("legacy rollback contract changed", after, *reloads)
|
||||
}
|
||||
restored, err := m.read(m.Name)
|
||||
if err != nil || !bytes.Equal(restored, config) {
|
||||
t.Fatal("rollback config bytes changed", err)
|
||||
}
|
||||
if point == "staged" || point == "backup" {
|
||||
afterJournal, err := m.read(managedJournalName)
|
||||
if err != nil || !bytes.Equal(journal, afterJournal) {
|
||||
t.Fatal("pre-prepare journal changed", err)
|
||||
}
|
||||
}
|
||||
assertActiveCandidates(t, m, db, ids)
|
||||
t.Logf("legacy restored config SHA256=%s", after.Hash)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
package main
|
||||
|
||||
// This corpus also runs unmodified against archived d324b41. It uses only
|
||||
// pre-extraction APIs, with explicit expected normalized facts, not wrappers.
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestYoutubeLegacyParserParity(t *testing.T) {
|
||||
good := "https://rr1---sn-alpha.googlevideo.com/videoplayback?expire=1800000000&sig=private-secret"
|
||||
format := func(raw, mime string) map[string]string { return map[string]string{"url": raw, "mimeType": mime} }
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
formats, adaptive []map[string]string
|
||||
want string
|
||||
}{
|
||||
{"ordinary-first", []map[string]string{format(good, "audio/mp4; codecs=mp4a")}, []map[string]string{format(good+"&second=1", "video/mp4")}, "audio/mp4"},
|
||||
{"nonmp4-fallback", []map[string]string{format(good, "video/webm")}, []map[string]string{format(good, "video/mp4")}, "video/mp4"},
|
||||
{"userinfo", []map[string]string{format(strings.Replace(good, "https://", "https://user@", 1), "video/mp4")}, nil, ""},
|
||||
{"fragment", []map[string]string{format(good+"#secret", "video/mp4")}, nil, ""},
|
||||
{"http", []map[string]string{format(strings.Replace(good, "https:", "http:", 1), "video/mp4")}, nil, ""},
|
||||
{"invalid-dns", []map[string]string{format(strings.Replace(good, "rr1---sn-alpha", "bad_host", 1), "video/mp4")}, nil, ""},
|
||||
{"sabr-only", nil, nil, ""},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
body, _ := json.Marshal(map[string]interface{}{"playabilityStatus": map[string]string{"status": "OK"}, "streamingData": map[string]interface{}{"formats": tc.formats, "adaptiveFormats": tc.adaptive, "serverAbrStreamingUrl": good}})
|
||||
r, capability, err := playerMediaResource(body)
|
||||
if err != nil || r.kind != tc.want || capability.OrdinaryURL != (tc.want != "") || capability.SABRSupported {
|
||||
t.Fatal(r.kind, capability, err)
|
||||
}
|
||||
if tc.want != "" && (r.url != good || r.host != "rr1---sn-alpha.googlevideo.com") {
|
||||
t.Fatal("normalized resource changed")
|
||||
}
|
||||
})
|
||||
}
|
||||
for _, body := range [][]byte{[]byte(`{"secret":`), bytes.Repeat([]byte("x"), playerResponseLimit+1)} {
|
||||
if _, _, err := playerMediaResource(body); err == nil || err.Error() != "invalid playable metadata" {
|
||||
t.Fatal("metadata error contract changed", err)
|
||||
}
|
||||
}
|
||||
for _, delta := range []time.Duration{-time.Hour, 19 * time.Minute, 21 * time.Minute} {
|
||||
r := mediaResource{fmt.Sprintf("https://rr1---sn-alpha.googlevideo.com/videoplayback?expire=%d&lsig=secret", time.Now().Add(delta).Unix()), "rr1---sn-alpha.googlevideo.com", "video/mp4"}
|
||||
if freshGooglevideoSample(r) != (delta > managedGooglevideoSampleTTL) {
|
||||
t.Fatal("inventory freshness changed", delta)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestYoutubeLegacyJournalParity(t *testing.T) {
|
||||
r, c, resources, _ := googlevideoRuntimeFixture(t)
|
||||
p, err := r.verifyGooglevideo(context.Background(), c, resources)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
db := testStore(t)
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer tx.Rollback()
|
||||
id, err := insertStrategyCandidate(tx, c.Group, c.Endpoints, c.Args, nil, c.Mode)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := saveAdaptiveGooglevideoEvidence(tx, id, p); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=multisplit", true)
|
||||
m, _ := managedFixture(t)
|
||||
ids := []int64{front, id} // No new asset requirement for native suffix policy.
|
||||
if err := m.Apply(db, ids, GooglevideoScopeSuffix); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
before, err := m.load()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
journalBytes, err := m.read(managedJournalName)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
config, err := m.read(m.Name)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Convert the actual producer facts to the exact historical v1 wire shape.
|
||||
p.Attestation.CheckedAt = time.Now().Add(-25 * time.Hour)
|
||||
raw, _ := json.Marshal(p)
|
||||
var fields map[string]json.RawMessage
|
||||
if err := json.Unmarshal(raw, &fields); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
delete(fields, "adapter")
|
||||
fields["version"] = json.RawMessage(`1`)
|
||||
raw, _ = json.Marshal(fields)
|
||||
if _, err := db.Exec("UPDATE googlevideo_scope_evidence SET proof=? WHERE candidate_id=?", string(raw), id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rendered, err := renderStoredManagedConfigScope(db, ids, GooglevideoScopeSuffix)
|
||||
if err != nil || !bytes.Equal(config, rendered) || managedHash(rendered) != before.Hash {
|
||||
t.Fatal("historical render/hash changed", err)
|
||||
}
|
||||
if err := m.Reconcile(db); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
active, err := m.ActiveCandidates(db)
|
||||
if err != nil || len(active) != 2 || active[0] != front || active[1] != id {
|
||||
t.Fatal(active, err)
|
||||
}
|
||||
after, err := m.load()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
a, _ := json.Marshal(before)
|
||||
b, _ := json.Marshal(after)
|
||||
if !bytes.Equal(a, b) {
|
||||
t.Fatal("historical journal changed")
|
||||
}
|
||||
afterBytes, err := m.read(managedJournalName)
|
||||
if err != nil || !bytes.Equal(journalBytes, afterBytes) {
|
||||
t.Fatal("historical journal bytes changed", err)
|
||||
}
|
||||
t.Logf("historical config SHA256=%s", before.Hash)
|
||||
}
|
||||
Reference in new issue
Block a user