Remove useless mutex

plc/impl.go

···
 
 import (
 	"context"
-	"sync"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/did-method-plc/go-didplc"
···
 )
 
 type plcImpl struct {
-	mu        sync.Mutex // probably redundant, but let's keep for now
 	validator OperationValidator
 }
 
···
 }
 
 func (plc *plcImpl) ValidateOperation(ctx context.Context, readTx transaction.Read, did string, opBytes []byte) error {
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	timestamp := syntax.Datetime(readTx.Timestamp().Format(types.ActualAtprotoDatetimeLayout))
 
 	// TODO set true to false only while importing old ops
···
 }
 
 func (plc *plcImpl) ExecuteOperation(ctx context.Context, tx transaction.Write, did string, opBytes []byte) error {
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	timestamp := syntax.Datetime(tx.Timestamp().Format(types.ActualAtprotoDatetimeLayout))
 
 	// TODO set true to false only while importing old ops
···
 	return nil
 }
 func (plc *plcImpl) ImportOperationFromAuthoritativeSource(ctx context.Context, tx transaction.Write, newEntry didplc.LogEntry) error {
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	newCID := newEntry.CID
 	newPrev := newEntry.Operation.AsOperation().PrevCIDStr()
 
···
 }
 
 func (plc *plcImpl) Resolve(ctx context.Context, tx transaction.Read, did string) (didplc.Doc, error) {
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	l, _, err := store.Tree.AuditLog(ctx, tx, did, false)
 	if err != nil {
 		return didplc.Doc{}, stacktrace.Propagate(err, "")
···
 	// if missing -> returns ErrDIDNotFound
 	// if tombstone -> returns log as normal
 
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	l, _, err := store.Tree.AuditLog(ctx, tx, did, false)
 	if err != nil {
 		return nil, stacktrace.Propagate(err, "")
···
 	// GetPlcAuditLog - /:did/log/audit - full audit log, with nullified
 	// if missing -> returns ErrDIDNotFound
 	// if tombstone -> returns log as normal
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	l, _, err := store.Tree.AuditLog(ctx, tx, did, false)
 	if err != nil {
 		return nil, stacktrace.Propagate(err, "")
···
 	// GetLastOp - /:did/log/last - latest op from audit log which isn't nullified (the latest op is guaranteed not to be nullified)
 	// if missing -> returns ErrDIDNotFound
 	// if tombstone -> returns tombstone op
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	l, _, err := store.Tree.AuditLog(ctx, tx, did, false)
 	if err != nil {
 		return didplc.OpEnum{}, stacktrace.Propagate(err, "")
···
 	// GetPlcData - /:did/data - similar to GetLastOp but applies a transformation on the op which normalizes it into a modern op
 	// if missing -> returns ErrDIDNotFound
 	// if tombstone -> returns ErrDIDGone
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	l, _, err := store.Tree.AuditLog(ctx, tx, did, false)
 	if err != nil {
 		return didplc.RegularOp{}, stacktrace.Propagate(err, "")
···
 }
 
 func (plc *plcImpl) Export(ctx context.Context, tx transaction.Read, after uint64, count int) ([]types.SequencedLogEntry, error) {
-	plc.mu.Lock()
-	defer plc.mu.Unlock()
-
 	entries, err := store.Tree.ExportOperations(ctx, tx, after, count)
 	return entries, stacktrace.Propagate(err, "")
 }