forked from longtao.wu/droboticflow
131 lines
4.0 KiB
Go
131 lines
4.0 KiB
Go
// query-read-builder only writes derived read models. It never processes work.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"droboticflow/internal/store"
|
|
"errors"
|
|
"flag"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
"go.mongodb.org/mongo-driver/mongo/readconcern"
|
|
"go.mongodb.org/mongo-driver/mongo/readpref"
|
|
"log"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
"time"
|
|
)
|
|
|
|
func main() {
|
|
once := flag.Bool("once", false, "build once; streaming freshness expires after exit")
|
|
ensure := flag.Bool("ensure-indexes", false, "explicitly create derived-data indexes before building")
|
|
shadowRun := flag.String("shadow-safety-run", "", "opt-in independently monitored shadow builder; no authority gates")
|
|
autoRecover := flag.Bool("auto-recover-transient", false, "automatically cool down and clear transient build failure fences in unattended mode")
|
|
flag.Parse()
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
if os.Getenv("QUERY_SERVING_READS") != "1" {
|
|
log.Fatal("explicit QUERY_SERVING_READS=1 is required")
|
|
}
|
|
uri, db := os.Getenv("QUERY_READ_MONGO_URI"), os.Getenv("QUERY_READ_MONGO_DB")
|
|
if uri == "" || db == "" {
|
|
log.Fatal("independent query database required; authority builds disabled")
|
|
}
|
|
client, err := mongo.Connect(ctx, options.Client().ApplyURI(uri).SetReadPreference(readpref.Primary()).SetReadConcern(readconcern.Majority()))
|
|
if err != nil {
|
|
log.Fatal("builder database unavailable")
|
|
}
|
|
defer client.Disconnect(context.Background())
|
|
s := store.NewMongoStore(client.Database(db))
|
|
if s.VerifyQueryReplicaTarget(ctx) != nil {
|
|
log.Fatal("projected query database identity unavailable")
|
|
}
|
|
closeServing, err := s.ConfigureQueryServingFromEnvironment()
|
|
if err != nil {
|
|
log.Fatal("builder accelerator configuration invalid")
|
|
}
|
|
defer closeServing()
|
|
workCtx := ctx
|
|
if *shadowRun != "" {
|
|
guarded, cancel := context.WithCancel(ctx)
|
|
defer cancel()
|
|
workCtx = guarded
|
|
if s.CheckQueryReplicaSafety(ctx, *shadowRun) != nil {
|
|
log.Print("shadow builder safety paused")
|
|
<-ctx.Done()
|
|
return
|
|
}
|
|
go func() {
|
|
ticker := time.NewTicker(5 * time.Second)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-guarded.Done():
|
|
return
|
|
case <-ticker.C:
|
|
short, stop := context.WithTimeout(guarded, 2*time.Second)
|
|
err := s.CheckQueryReplicaSafety(short, *shadowRun)
|
|
stop()
|
|
if err != nil {
|
|
cancel()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
if *ensure {
|
|
if s.EnsureQueryReadModelIndexes(workCtx) != nil {
|
|
log.Fatal("derived index creation failed")
|
|
}
|
|
}
|
|
b := store.NewQueryReadBuilder(s)
|
|
defer b.Close()
|
|
if *once {
|
|
if b.RunOnce(workCtx) != nil {
|
|
log.Fatal("initial materialization incomplete")
|
|
}
|
|
return
|
|
}
|
|
for workCtx.Err() == nil {
|
|
if err := b.Run(workCtx); err != nil && workCtx.Err() == nil {
|
|
if errors.Is(err, store.ErrQueryBuildStopped) {
|
|
if *autoRecover && *shadowRun == "" {
|
|
log.Print("query builder hit stopped fence; cooling down before checking transient recovery")
|
|
cooldown := time.NewTimer(15 * time.Second)
|
|
select {
|
|
case <-workCtx.Done():
|
|
cooldown.Stop()
|
|
return
|
|
case <-cooldown.C:
|
|
}
|
|
resetCtx, cancel := context.WithTimeout(workCtx, 5*time.Second)
|
|
cleared, clearErr := s.ResetTransientQueryBuildFailures(resetCtx)
|
|
cancel()
|
|
if clearErr == nil && cleared > 0 {
|
|
log.Print("query builder cleared transient failure fence; resuming checkpoint")
|
|
continue
|
|
}
|
|
log.Print("query builder stopped on non-transient failure; checkpoint retained; explicit recovery required")
|
|
<-workCtx.Done()
|
|
return
|
|
}
|
|
log.Print("query builder stopped; checkpoint retained; explicit recovery required")
|
|
<-workCtx.Done()
|
|
return
|
|
}
|
|
log.Print("query builder retrying; durable build checkpoint retained")
|
|
}
|
|
select {
|
|
case <-workCtx.Done():
|
|
if ctx.Err() == nil {
|
|
log.Print("shadow builder safety paused; explicit operator restart required")
|
|
<-ctx.Done()
|
|
}
|
|
return
|
|
case <-time.After(5 * time.Second):
|
|
}
|
|
}
|
|
}
|