droboticflow/internal/store/query_replica_delete.go

160 lines
5.0 KiB
Go

package store
import (
"context"
"time"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// ReconcileDeleteStep handles one bounded part of a durable deletion intent.
// It reads only source identities, never annotator payloads. Survivors retain
// their data; a cancelled deletion is not replayed or restored from snapshots.
func (q *QueryReplica) ReconcileDeleteStep(ctx context.Context) (bool, error) {
if _, e := q.sourcePermit(ctx, 1); e != nil {
return false, e
}
sourceCtx, sourceCancel := q.sourceContext(ctx)
defer sourceCancel()
var i queryDeleteIntent
e := q.Source.db.Collection(querySyncDeleteCollection).FindOne(sourceCtx, bson.M{"$or": bson.A{bson.M{"phase": bson.M{"$in": bson.A{"complete", "cancelled", "reconcile"}}}, bson.M{"phase": bson.M{"$in": bson.A{"prepared", "deleting"}}, "leaseUntil": bson.M{"$lte": time.Now().UTC()}}}}, options.FindOne().SetMaxTime(1500*time.Millisecond).SetSort(bson.D{{Key: "audit", Value: 1}, {Key: "createdAt", Value: 1}})).Decode(&i)
if e == mongo.ErrNoDocuments {
return false, nil
}
if e != nil {
return false, e
}
if queryReplicaFields[i.Collection] == "" {
return false, ErrQueryReplicaUnsupported
}
if ok, e := q.recoverSourceClaims(ctx, i); e != nil || !ok {
return false, e
}
key := "delete/" + i.ID
var cp queryReplicaCheckpoint
e = q.control().FindOne(ctx, bson.M{"_id": key}).Decode(&cp)
if e != nil && e != mongo.ErrNoDocuments {
return false, e
}
if cp.Complete {
_, e = q.sourceIntentUpdate(ctx, bson.M{"_id": i.ID, "phase": "reconcile"}, bson.M{"$set": bson.M{"phase": "acknowledged", "expireAt": time.Now().UTC().Add(7 * 24 * time.Hour)}})
return true, e
}
filter := bson.M{}
if cp.HasLast || cp.Last != nil {
filter["$expr"] = bson.M{"$gt": bson.A{"$_id", bson.M{"$literal": cp.Last}}}
}
cur, e := q.Target.db.Collection(i.Collection).Find(ctx, filter, options.Find().SetProjection(bson.M{"_id": 1, "_queryReplica.sourceId": 1}).SetSort(bson.D{{Key: "_id", Value: 1}}).SetHint("_id_").SetLimit(q.limit()))
if e != nil {
return false, e
}
defer cur.Close(ctx)
var rows []bson.M
var ids bson.A
var last any
for cur.Next(ctx) {
var d bson.M
if e = cur.Decode(&d); e != nil {
return false, e
}
rows = append(rows, d)
last = d["_id"]
ids = append(ids, deletionDoc(d["_queryReplica"])["sourceId"])
}
if e = cur.Err(); e != nil {
return false, e
}
present := []any{}
if len(ids) > 0 {
permitted, err := q.sourcePermit(ctx, int64(len(ids)))
if err != nil {
return false, err
}
if permitted < int64(len(ids)) {
if err = q.PauseSafety(ctx, "pilot_budget"); err != nil {
return false, err
}
return false, ErrQueryReplicaPaused
}
sourceCtx, sourceCancel := q.sourceContext(ctx)
defer sourceCancel()
src, e := q.Source.db.Collection(i.Collection).Find(sourceCtx, bson.M{"_id": bson.M{"$in": ids}}, options.Find().SetProjection(bson.M{"_id": 1}).SetLimit(int64(len(ids))).SetBatchSize(int32(len(ids))).SetMaxTime(1500*time.Millisecond))
if e != nil {
return false, e
}
for src.Next(ctx) {
var d bson.M
if e = src.Decode(&d); e != nil {
src.Close(ctx)
return false, e
}
present = append(present, d["_id"])
}
e = src.Err()
src.Close(ctx)
if e != nil {
return false, e
}
}
if e := q.paceRows(ctx, len(present)); e != nil {
return false, e
}
absent := []bson.M{}
for _, r := range rows {
id := deletionDoc(r["_queryReplica"])["sourceId"]
exists := false
for _, v := range present {
if bsonEqual(id, v) {
exists = true
break
}
}
if !exists {
absent = append(absent, r)
}
}
e = q.transaction(ctx, func(sc mongo.SessionContext) error {
deltas := map[string]*poolBucketDelta{}
for _, r := range absent {
filter := bson.M{"_id": r["_id"], "_queryReplica.sourceId": deletionDoc(r["_queryReplica"])["sourceId"]}
var old bson.M
if i.Collection == "humanItems" {
e := q.Target.humanItems.FindOne(sc, filter, options.FindOne().SetProjection(poolBucketProjection())).Decode(&old)
if e != nil && e != mongo.ErrNoDocuments {
return e
}
}
result, e := q.Target.db.Collection(i.Collection).DeleteOne(sc, filter)
if e != nil {
return e
}
if result.DeletedCount == 1 && i.Collection == "humanItems" {
if err := addPoolBucketDelta(deltas, old, -1); err != nil {
return err
}
}
}
if e := q.writePoolBucketDeltas(sc, deltas); e != nil {
return e
}
if len(absent) > 0 {
if _, e := q.control().UpdateOne(sc, bson.M{"_id": "state"}, bson.M{"$inc": bson.M{"factEpoch": int64(1), "poolBucketEpoch": int64(1), "collectionEpoch." + i.Collection: int64(1)}}, options.Update().SetUpsert(true)); e != nil {
return e
}
}
d := bson.M{"complete": int64(len(rows)) < q.limit()}
if int64(len(rows)) < q.limit() {
d["expireAt"] = time.Now().UTC().Add(7 * 24 * time.Hour)
}
if len(rows) > 0 {
d["hasLast"] = true
d["last"] = last
}
_, e := q.control().UpdateOne(sc, bson.M{"_id": key}, bson.M{"$set": d}, options.Update().SetUpsert(true))
return e
})
return true, e
}