droboticflow/internal/store/query_sync_delete.go

218 lines
7.1 KiB
Go

package store
import (
"context"
"errors"
"time"
"droboticflow/internal/domain"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
const queryDeleteLease = 30 * time.Second
var errQueryDeleteFenced = errors.New("query deletion intent fenced")
type queryDeleteIntent struct {
ID string `bson:"_id"`
Audit bool `bson:"audit,omitempty"`
Collection string `bson:"collection"`
Phase string `bson:"phase"`
LeaseUntil time.Time `bson:"leaseUntil"`
CreatedAt time.Time `bson:"createdAt"`
}
func (c *queryCollection) deleteIntents() *mongo.Collection {
return c.Database().Collection(querySyncDeleteCollection)
}
func (c *queryCollection) beginDelete(ctx context.Context) (queryDeleteIntent, func(), error) {
now := time.Now().UTC()
i := queryDeleteIntent{ID: domain.NewID("query-delete"), Collection: c.Name(), Phase: "prepared", LeaseUntil: now.Add(queryDeleteLease), CreatedAt: now}
if _, e := c.deleteIntents().InsertOne(ctx, i); e != nil {
return i, func() {}, e
}
stop := make(chan struct{})
done := make(chan struct{})
go func() {
defer close(done)
ticker := time.NewTicker(queryDeleteLease / 3)
defer ticker.Stop()
for {
select {
case <-stop:
return
case <-ticker.C:
renew, cancel := context.WithTimeout(context.Background(), 2*time.Second)
_, _ = c.deleteIntents().UpdateOne(renew, bson.M{"_id": i.ID, "phase": bson.M{"$in": bson.A{"prepared", "deleting"}}}, bson.M{"$set": bson.M{"leaseUntil": time.Now().UTC().Add(queryDeleteLease)}})
cancel()
}
}
}()
return i, func() { close(stop); <-done }, nil
}
func (c *queryCollection) deletePhase(ctx context.Context, id, from, to string) error {
r, e := c.deleteIntents().UpdateOne(ctx, bson.M{"_id": id, "phase": from}, bson.M{"$set": bson.M{"phase": to}})
if e != nil {
return e
}
if r.MatchedCount != 1 {
return errQueryDeleteFenced
}
return nil
}
func deleteOptionsRead(opts []*options.DeleteOptions, sorts ...any) *options.FindOneAndUpdateOptions {
o := options.FindOneAndUpdate().SetProjection(bson.M{"_id": 1}).SetReturnDocument(options.After)
for _, v := range opts {
if v == nil {
continue
}
o.Collation = v.Collation
o.Hint = v.Hint
o.Let = v.Let
o.Comment = v.Comment
}
if len(sorts) > 0 && sorts[0] != nil {
o.SetSort(sorts[0])
}
return o
}
func (c *queryCollection) prepareDelete(ctx context.Context, filter any, many bool, opts []*options.DeleteOptions, sorts ...any) (queryDeleteIntent, any, func(), error) {
i, finish, e := c.beginDelete(ctx)
if e != nil {
return i, nil, finish, e
}
claim := bson.M{"$set": bson.M{querySyncField + ".deleteClaim": i.ID}}
available := bson.M{"$and": bson.A{filter, bson.M{querySyncField + ".deleteClaim": bson.M{"$exists": false}}}}
constrained := bson.M{"$and": bson.A{filter, bson.M{querySyncField + ".deleteClaim": i.ID}}}
if many {
o := options.Update()
for _, v := range opts {
if v == nil {
continue
}
o.Collation = v.Collation
o.Hint = v.Hint
o.Let = v.Let
o.Comment = v.Comment
}
if _, e = c.Collection.UpdateMany(ctx, available, claim, o); e != nil {
return i, nil, finish, e
}
} else {
var selected bson.M
e = c.Collection.FindOneAndUpdate(ctx, available, claim, deleteOptionsRead(opts, sorts...)).Decode(&selected)
if errors.Is(e, mongo.ErrNoDocuments) {
err := c.Collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 1})).Err()
if err == nil {
return i, nil, finish, errQueryDeleteFenced
}
if !errors.Is(err, mongo.ErrNoDocuments) {
return i, nil, finish, err
}
_ = c.deletePhase(ctx, i.ID, "prepared", "complete")
return i, constrained, finish, nil
}
if e != nil {
return i, nil, finish, e
}
constrained["$and"] = bson.A{filter, bson.M{"_id": selected["_id"], querySyncField + ".deleteClaim": i.ID}}
}
if many {
err := c.Collection.FindOne(ctx, bson.M{"$and": bson.A{filter, bson.M{querySyncField + ".deleteClaim": bson.M{"$ne": i.ID}}}}, options.FindOne().SetProjection(bson.M{"_id": 1})).Err()
if err == nil {
return i, nil, finish, errQueryDeleteFenced
}
if !errors.Is(err, mongo.ErrNoDocuments) {
return i, nil, finish, err
}
}
if e = c.deletePhase(ctx, i.ID, "prepared", "deleting"); e != nil {
return i, nil, finish, e
}
return i, constrained, finish, nil
}
func (c *queryCollection) DeleteOne(ctx context.Context, f any, o ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
if !c.tracks() {
return c.Collection.DeleteOne(ctx, f, o...)
}
i, filter, finish, e := c.prepareDelete(ctx, f, false, o)
defer finish()
if e != nil {
return nil, e
}
r, e := c.Collection.DeleteOne(ctx, filter, o...)
if e == nil {
_ = c.deletePhase(ctx, i.ID, "deleting", "complete")
}
return r, e
}
func (c *queryCollection) DeleteMany(ctx context.Context, f any, o ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
if !c.tracks() {
return c.Collection.DeleteMany(ctx, f, o...)
}
i, filter, finish, e := c.prepareDelete(ctx, f, true, o)
defer finish()
if e != nil {
return nil, e
}
r, e := c.Collection.DeleteMany(ctx, filter, o...)
if e == nil {
_ = c.deletePhase(ctx, i.ID, "deleting", "complete")
}
return r, e
}
func (c *queryCollection) FindOneAndDelete(ctx context.Context, f any, o ...*options.FindOneAndDeleteOptions) *mongo.SingleResult {
if !c.tracks() {
return c.Collection.FindOneAndDelete(ctx, f, o...)
}
del := options.Delete()
var sort any
for _, v := range o {
if v == nil {
continue
}
sort = v.Sort
del.Collation = v.Collation
del.Hint = v.Hint
del.Let = v.Let
del.Comment = v.Comment
}
i, filter, finish, e := c.prepareDelete(ctx, f, false, []*options.DeleteOptions{del}, sort)
defer finish()
if e != nil {
return mongo.NewSingleResultFromDocument(nil, e, nil)
}
r := c.Collection.FindOneAndDelete(ctx, filter, o...)
if r.Err() == nil || errors.Is(r.Err(), mongo.ErrNoDocuments) {
_ = c.deletePhase(ctx, i.ID, "deleting", "complete")
}
return r
}
// A crashed prepared operation cannot start deleting after this CAS. For an
// already deleting operation, clearing its per-record claims fences any late
// delete command before reconciliation. No annotation/state is restored.
func (c *queryCollection) recoverDelete(ctx context.Context, i queryDeleteIntent, now time.Time) (bool, error) {
if i.Phase == "prepared" || i.Phase == "deleting" {
if i.LeaseUntil.After(now) {
return false, nil
}
r, e := c.deleteIntents().UpdateOne(ctx, bson.M{"_id": i.ID, "phase": i.Phase, "leaseUntil": bson.M{"$lte": now}}, bson.M{"$set": bson.M{"phase": "cancelled"}})
if e != nil {
return false, e
}
if r.MatchedCount != 1 {
return false, nil
}
} else if i.Phase != "complete" && i.Phase != "cancelled" && i.Phase != "reconcile" {
return false, nil
}
if _, e := c.Collection.UpdateMany(ctx, bson.M{querySyncField + ".deleteClaim": i.ID}, bson.M{"$unset": bson.M{querySyncField + ".deleteClaim": ""}}); e != nil {
return false, e
}
_, e := c.deleteIntents().UpdateOne(ctx, bson.M{"_id": i.ID, "phase": bson.M{"$in": bson.A{"complete", "cancelled", "reconcile"}}}, bson.M{"$set": bson.M{"phase": "reconcile"}})
return e == nil, e
}