218 lines
7.1 KiB
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
|
|
}
|