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>
219 lines
7.3 KiB
Go
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)
|
|
}
|