forked from longtao.wu/droboticflow
160 lines
5.0 KiB
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
|
|
}
|