s/dedup/dedupe (#777)

Author: phbnf

antispam.go

@@ -22,7 +22,7 @@ import (
 	lru "github.com/hashicorp/golang-lru/v2"
 )
 
-// newInMemoryDedupe wraps an Add function to prevent duplicate entries being written to the underlying
+// newInMemoryDedup wraps an Add function to prevent duplicate entries being written to the underlying
 // storage by keeping an in-memory cache of recently seen entries.
 // Where an existing entry has already been `Add`ed, the previous `IndexFuture` will be returned.
 // When no entry is found in the cache, the delegate method will be called to store the entry, and
@@ -31,39 +31,39 @@ import (
 // Internally this uses a cache with a max size configured by the size parameter.
 // If the entry being `Add`ed is not found in the cache, then it calls the delegate.
 //
-// This object can be used in isolation, or in conjunction with a persistent dedupe implementation.
-// When using this with a persistent dedupe, the persistent layer should be the delegate of this
-// InMemoryDedupe. This allows recent duplicates to be deduplicated in memory, reducing the need to
+// This object can be used in isolation, or in conjunction with a persistent dedup implementation.
+// When using this with a persistent dedup, the persistent layer should be the delegate of this
+// InMemoryDedup. This allows recent duplicates to be deduplicated in memory, reducing the need to
 // make calls to a persistent storage.
-func newInMemoryDedupe(size uint) func(AddFn) AddFn {
+func newInMemoryDedup(size uint) func(AddFn) AddFn {
 	return func(af AddFn) AddFn {
 		c, err := lru.New[string, func() IndexFuture](int(size))
 		if err != nil {
 			panic(fmt.Errorf("lru.New(%d): %v", size, err))
 		}
-		dedupe := &inMemoryDedupe{
+		dedup := &inMemoryDedup{
 			delegate: af,
 			cache:    c,
 		}
-		return dedupe.add
+		return dedup.add
 	}
 }
 
-type inMemoryDedupe struct {
+type inMemoryDedup struct {
 	delegate func(ctx context.Context, e *Entry) IndexFuture
 	cache    *lru.Cache[string, func() IndexFuture]
 }
 
 // Add adds the entry to the underlying delegate only if e hasn't been recently seen. In either case,
 // an IndexFuture will be returned that the client can use to get the sequence number of this entry.
-func (d *inMemoryDedupe) add(ctx context.Context, e *Entry) IndexFuture {
+func (d *inMemoryDedup) add(ctx context.Context, e *Entry) IndexFuture {
 	ctx, span := tracer.Start(ctx, "tessera.Appender.inmemoryDedup.Add")
 	defer span.End()
 
 	id := string(e.Identity())
 
 	f := sync.OnceValue(func() IndexFuture {
-		// However many calls with the same entry come in and are deduped, we should only call delegate
+		// However many calls with the same entry come in and are deduplicated, we should only call delegate
 		// once for each unique entry:
 		df := d.delegate(ctx, e)
 

antispam_test.go

@@ -23,7 +23,7 @@ import (
 	"testing"
 )
 
-func TestDedupe(t *testing.T) {
+func TestDedup(t *testing.T) {
 	ctx := context.Background()
 	testCases := []struct {
 		desc     string
@@ -59,18 +59,18 @@ func TestDedupe(t *testing.T) {
 					return Index{Index: thisIdx}, nil
 				}
 			}
-			dedupeAdd := newInMemoryDedupe(256)(delegate)
+			dedupAdd := newInMemoryDedup(256)(delegate)
 
 			// Add foo, bar, baz to prime the cache to make things interesting
 			for _, s := range []string{"foo", "bar", "baz"} {
-				if _, err := dedupeAdd(ctx, NewEntry([]byte(s)))(); err != nil {
-					t.Fatalf("dedupeAdd(%q): %v", s, err)
+				if _, err := dedupAdd(ctx, NewEntry([]byte(s)))(); err != nil {
+					t.Fatalf("dedupAdd(%q): %v", s, err)
 				}
 			}
 
-			i, err := dedupeAdd(ctx, NewEntry([]byte(tC.newValue)))()
+			i, err := dedupAdd(ctx, NewEntry([]byte(tC.newValue)))()
 			if err != nil {
-				t.Fatalf("dedupeAdd(%q): %v", tC.newValue, err)
+				t.Fatalf("dedupAdd(%q): %v", tC.newValue, err)
 			}
 			if i.Index != tC.wantIdx {
 				t.Errorf("got Index != want Index (%d != %d)", i.Index, tC.wantIdx)
@@ -83,7 +83,7 @@ func TestDedupe(t *testing.T) {
 	}
 }
 
-func TestDedupeDoesNotCacheError(t *testing.T) {
+func TestDedupDoesNotCacheError(t *testing.T) {
 	idx := uint64(0)
 	rErr := true
 
@@ -106,24 +106,24 @@ func TestDedupeDoesNotCacheError(t *testing.T) {
 			return Index{Index: thisIdx}, err
 		}
 	}
-	dedupeAdd := newInMemoryDedupe(256)(delegate)
+	dedupAdd := newInMemoryDedup(256)(delegate)
 
 	k := "foo"
 	for i := range 10 {
-		idx, err := dedupeAdd(t.Context(), NewEntry([]byte(k)))()
+		idx, err := dedupAdd(t.Context(), NewEntry([]byte(k)))()
 
 		// We expect an error from the delegate the first time.
 		if i == 0 && err == nil {
-			t.Errorf("dedupeAdd(%q)@%d: was successful, want error", k, i)
+			t.Errorf("dedupAdd(%q)@%d: was successful, want error", k, i)
 			continue
 		}
 		// But the 2nd call should work.
 		if i > 0 && err != nil {
-			t.Errorf("dedupeAdd(%q)@%d: got %v, want no error", k, i, err)
+			t.Errorf("dedupAdd(%q)@%d: got %v, want no error", k, i, err)
 			continue
 		}
 
-		// After which, all subsequent adds should dedupe to that successful add.
+		// After which, all subsequent adds should dedup to that successful add.
 		if i > 1 && !idx.IsDup {
 			t.Errorf("got IsDup=false, want isDup=true")
 			continue
@@ -134,7 +134,7 @@ func TestDedupeDoesNotCacheError(t *testing.T) {
 	}
 }
 
-func BenchmarkDedupe(b *testing.B) {
+func BenchmarkDedup(b *testing.B) {
 	ctx := context.Background()
 	// Outer loop is for benchmark calibration, inside here is each individual run of the benchmark
 	for b.Loop() {
@@ -146,13 +146,13 @@ func BenchmarkDedupe(b *testing.B) {
 				return Index{Index: thisIdx}, nil
 			}
 		}
-		dedupeAdd := newInMemoryDedupe(256)(delegate)
+		dedupAdd := newInMemoryDedup(256)(delegate)
 		wg := &sync.WaitGroup{}
 		// Loop to create a bunch of leaves in parallel to test lock contention
 		for leafIndex := range 1024 {
 			wg.Add(1)
 			go func(index int) {
-				_, err := dedupeAdd(ctx, NewEntry(fmt.Appendf(nil, "leaf with value %d", index%sha256.Size)))()
+				_, err := dedupAdd(ctx, NewEntry(fmt.Appendf(nil, "leaf with value %d", index%sha256.Size)))()
 				if err != nil {
 					b.Error(err)
 				}

append_lifecycle.go

@@ -580,7 +580,7 @@ func (o AppendOptions) valid() error {
 //
 // For more details on how the antispam mechanism works, including tuning guidance, see docs/design/antispam.md.
 func (o *AppendOptions) WithAntispam(inMemEntries uint, as Antispam) *AppendOptions {
-	o.addDecorators = append(o.addDecorators, newInMemoryDedupe(inMemEntries))
+	o.addDecorators = append(o.addDecorators, newInMemoryDedup(inMemEntries))
 	if as != nil {
 		o.addDecorators = append(o.addDecorators, as.Decorator())
 		o.followers = append(o.followers, as.Follower(o.bundleIDHasher))