Files
zapret-autotune/cmd/zapret-autotune/managed_experimental_recovery.go
T
ZeusinaandGPT-6 Bot 3fc8563995 feat: discover and qualify Googlevideo CDNs autonomously
Retain strict three-host native qualification, discover fresh representative inventory automatically, and recheck deployed media before promotion. Document offline-only verification and outstanding field gates.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-13 10:12:10 +03:00

219 lines
7.3 KiB
Go

package main
import (
"context"
"crypto/sha256"
"errors"
"fmt"
"os"
"strconv"
"strings"
"time"
)
var errManagedExperimentalUnqualified = errors.New("experimental googlevideo suffix: operational health is not family qualification")
// URLs are trusted Player inventory, never rewritten or persisted.
func freshExperimentalMedia(r mediaResource) bool {
u, err := privateResourceURL(r.url, r.host)
if err != nil || !strings.HasSuffix(r.host, ".googlevideo.com") || u.Path != "/videoplayback" || (r.kind != "video/mp4" && r.kind != "audio/mp4") {
return false
}
q := u.Query()
expires, err := strconv.ParseInt(q.Get("expire"), 10, 64)
return err == nil && expires > time.Now().Unix()+120 && (q.Get("sig") != "" || q.Get("signature") != "" || q.Get("lsig") != "")
}
func experimentalMedia(ctx context.Context, d managedRecoveryDeps) (mediaResource, error) {
i, err := d.resources(ctx)
var fatal *managedRecoveryFatal
var failure *managedResourceFailure
// An unrelated metadata/image failure cannot conceal usable media, but a
// mixed safety/infrastructure error must not be turned into transfer absence.
unrelated := errors.As(err, &failure) && assetEndpoint(failure.Host) && (err == failure && failure.Err == nil || managedGooglevideoTransferNonpass(err))
if ctx.Err() != nil || errors.As(err, &fatal) && !unrelated || errors.Is(err, context.Canceled) || err != nil && !unrelated {
return mediaResource{}, managedRecoveryContextError(ctx, err)
}
if !freshExperimentalMedia(i.media) {
return mediaResource{}, &managedResourceFailure{"media", "unknown", nil}
}
return i.media, nil
}
func recoverManagedExperimental(ctx context.Context, d managedRecoveryDeps) (int64, error) {
if !d.service || d.resources == nil || d.recheckExperimental == nil {
return 0, errManagedGGCUnresolved
}
ids, err := d.transaction.ActiveCandidates(d.db)
if err != nil {
return 0, &managedRecoveryFatal{Err: err}
}
j, err := d.transaction.load()
if err != nil {
return 0, &managedRecoveryFatal{Err: err}
}
for _, id := range ids {
c, err := readStrategyCandidate(d.db, id)
if err != nil {
return 0, &managedRecoveryFatal{Err: err}
}
if experimentalGooglevideo(j.Scope, c) {
r, err := experimentalMedia(ctx, d)
if err == nil {
err = d.recheckExperimental(ctx, c, r, d.transaction)
}
if err == nil && d.mediaSamples != nil && d.verifyGooglevideo != nil {
// One-host operational health never promotes the experiment. Only
// fresh representative inventory and a completed owned proof may.
qualified, err := qualifyManagedGooglevideo(ctx, d)
if err != nil {
return id, err
}
return qualified, nil
}
return id, managedRecoveryContextError(ctx, err)
}
}
return 0, &managedRecoveryFatal{Err: errors.New("owned experimental candidate missing")}
}
func newManagedExperimentalRecheck(target managedDeps, d managedRecoveryDeps) func(context.Context, storedCandidate, mediaResource, *managedTransaction) error {
runtime := newManagedAssetRuntime(target)
return func(ctx context.Context, c storedCandidate, resource mediaResource, transaction *managedTransaction) error {
// The adapter is constructed with path-only dependencies. Use this job's
// bound hooks for ownership checks and reconciliation, not that stale copy.
d := d
d.transaction = transaction
guard := func() error {
if err := runtime.guard(); err != nil {
return err
}
lua, err := os.ReadFile("/opt/zapret2/lua/zapret-auto.lua")
if err != nil || fmt.Sprintf("%x", sha256.Sum256(lua)) != managedGooglevideoLuaHash {
return errors.New("unverified native automation Lua source")
}
_, err = d.transaction.ActiveCandidates(d.db)
return err
}
restart := func(ctx context.Context) (err error) {
// Existing daemon protocol stops/joins before starting the same full set.
// Never activate a pending or drifted deployment after a partial stop.
defer func() {
if err != nil {
cleanup, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
defer cancel()
if e := d.transaction.Reconcile(d.db); e != nil {
err = errors.Join(err, e)
} else {
err = errors.Join(err, d.run(cleanup, managedZapretScript, "start"))
}
}
}()
if err = d.run(ctx, managedZapretScript, "stop"); err != nil {
return err
}
if err = d.transaction.Reconcile(d.db); err != nil {
return err
}
return d.run(ctx, managedZapretScript, "start")
}
if !experimentalGooglevideo(GooglevideoScopeExperimental, c) {
return &managedRecoveryFatal{Err: errors.New("unaudited experimental candidate")}
}
ownedGuard := func() error {
if err := guard(); err != nil {
return err
}
j, err := d.transaction.load()
if err != nil {
return err
}
if j.Scope == GooglevideoScopeExperimental {
for _, id := range j.Candidates {
if id == c.ID {
return nil
}
}
}
return errors.New("experimental ownership changed")
}
return recheckDeployedExperimental(ctx, resource, ownedGuard, func(ctx context.Context) error {
if err := ownedGuard(); err != nil {
return err
}
return restart(ctx)
}, func(ctx context.Context) (mediaResource, error) {
return experimentalMedia(ctx, d)
}, func(ctx context.Context, r mediaResource, protocol string) error {
_, _, err := collectMediaTransfer(ctx, runtime.proxy, r, protocol, runtime.curl)
return err
})
}
}
// No temporary NFQ worker: successful learning stays in the deployed daemon RAM.
func recheckDeployedExperimental(ctx context.Context, resource mediaResource, guard func() error, restart func(context.Context) error, fresh func(context.Context) (mediaResource, error), transfer func(context.Context, mediaResource, string) error) error {
check := func(ctx context.Context, protocol string) error {
if err := ctx.Err(); err != nil {
return err
}
if err := guard(); err != nil {
return &managedRecoveryFatal{Err: err}
}
if !freshExperimentalMedia(resource) {
var err error
resource, err = fresh(ctx)
if err != nil {
return err
}
if !freshExperimentalMedia(resource) {
return &managedResourceFailure{"media", "unknown", nil}
}
}
return managedRecoveryContextError(ctx, transfer(ctx, resource, protocol))
}
sample := func() error {
for _, protocol := range []string{"tls12", "tls13"} {
for n := 0; n < 3; n++ {
if err := check(ctx, protocol); err != nil {
return err
}
}
}
return nil
}
err := sample()
if err == nil || !managedGooglevideoTransferNonpass(err) {
return err
}
if err := restart(ctx); err != nil {
return &managedRecoveryFatal{Err: managedRecoveryContextError(ctx, err)}
}
warm, cancel := context.WithTimeout(ctx, 120*time.Second)
defer cancel()
learned := map[string]bool{}
for n := 0; n < 10 && len(learned) < 2; n++ {
protocol := []string{"tls12", "tls13"}[n%2]
err = check(warm, protocol)
if ctx.Err() != nil {
return managedRecoveryContextError(ctx, err)
}
if warm.Err() != nil && managedRecoveryTimeoutSafe(err) {
break
}
if err != nil && !managedGooglevideoTransferNonpass(err) {
return err
}
if err == nil {
learned[protocol] = true
}
}
if len(learned) == 2 {
err = sample()
if err == nil || !managedGooglevideoTransferNonpass(err) {
return err
}
}
return fmt.Errorf("experimental media relearning exhausted: %w", errNoQualifiedStrategy)
}