Use BlobHandle in index methods

internal/repository/index.go

@@ -165,7 +165,8 @@ func (idx *Index) StorePack(id restic.ID, blobs []restic.Blob) {
 func (idx *Index) toPackedBlob(e *indexEntry, t restic.BlobType) restic.PackedBlob {
 	return restic.PackedBlob{
 		Blob: restic.Blob{
-			BlobHandle: restic.BlobHandle{ID: e.id,
+			BlobHandle: restic.BlobHandle{
+				ID:   e.id,
 				Type: t},
 			Length: uint(e.length),
 			Offset: uint(e.offset),
@@ -176,12 +177,12 @@ func (idx *Index) toPackedBlob(e *indexEntry, t restic.BlobType) restic.PackedBl
 
 // Lookup queries the index for the blob ID and returns all entries including
 // duplicates. Adds found entries to blobs and returns the result.
-func (idx *Index) Lookup(id restic.ID, t restic.BlobType, pbs []restic.PackedBlob) []restic.PackedBlob {
+func (idx *Index) Lookup(bh restic.BlobHandle, pbs []restic.PackedBlob) []restic.PackedBlob {
 	idx.m.Lock()
 	defer idx.m.Unlock()
 
-	idx.byType[t].foreachWithID(id, func(e *indexEntry) {
-		pbs = append(pbs, idx.toPackedBlob(e, t))
+	idx.byType[bh.Type].foreachWithID(bh.ID, func(e *indexEntry) {
+		pbs = append(pbs, idx.toPackedBlob(e, bh.Type))
 	})
 
 	return pbs
@@ -206,20 +207,20 @@ func (idx *Index) ListPack(id restic.ID) (pbs []restic.PackedBlob) {
 }
 
 // Has returns true iff the id is listed in the index.
-func (idx *Index) Has(id restic.ID, t restic.BlobType) bool {
+func (idx *Index) Has(bh restic.BlobHandle) bool {
 	idx.m.Lock()
 	defer idx.m.Unlock()
 
-	return idx.byType[t].get(id) != nil
+	return idx.byType[bh.Type].get(bh.ID) != nil
 }
 
 // LookupSize returns the length of the plaintext content of the blob with the
 // given id.
-func (idx *Index) LookupSize(id restic.ID, t restic.BlobType) (plaintextLength uint, found bool) {
+func (idx *Index) LookupSize(bh restic.BlobHandle) (plaintextLength uint, found bool) {
 	idx.m.Lock()
 	defer idx.m.Unlock()
 
-	e := idx.byType[t].get(id)
+	e := idx.byType[bh.Type].get(bh.ID)
 	if e == nil {
 		return 0, false
 	}
@@ -596,8 +597,9 @@ func DecodeIndex(buf []byte, id restic.ID) (idx *Index, oldFormat bool, err erro
 
 		for _, blob := range pack.Blobs {
 			idx.store(packID, restic.Blob{
-				BlobHandle: restic.BlobHandle{Type: blob.Type,
-					ID: blob.ID},
+				BlobHandle: restic.BlobHandle{
+					Type: blob.Type,
+					ID:   blob.ID},
 				Offset: blob.Offset,
 				Length: blob.Length,
 			})

internal/repository/index_test.go

@@ -12,13 +12,7 @@ import (
 )
 
 func TestIndexSerialize(t *testing.T) {
-	type testEntry struct {
-		id             restic.ID
-		pack           restic.ID
-		tpe            restic.BlobType
-		offset, length uint
-	}
-	tests := []testEntry{}
+	tests := []restic.PackedBlob{}
 
 	idx := repository.NewIndex()
 
@@ -28,28 +22,17 @@ func TestIndexSerialize(t *testing.T) {
 
 		pos := uint(0)
 		for j := 0; j < 20; j++ {
-			id := restic.NewRandomID()
 			length := uint(i*100 + j)
-			idx.Store(restic.PackedBlob{
+			pb := restic.PackedBlob{
 				Blob: restic.Blob{
-					BlobHandle: restic.BlobHandle{
-						Type: restic.DataBlob,
-						ID:   id,
-					},
-					Offset: pos,
-					Length: length,
+					BlobHandle: restic.NewRandomBlobHandle(),
+					Offset:     pos,
+					Length:     length,
 				},
 				PackID: packID,
-			})
-
-			tests = append(tests, testEntry{
-				id:     id,
-				pack:   packID,
-				tpe:    restic.DataBlob,
-				offset: pos,
-				length: length,
-			})
-
+			}
+			idx.Store(pb)
+			tests = append(tests, pb)
 			pos += length
 		}
 	}
@@ -73,58 +56,41 @@ func TestIndexSerialize(t *testing.T) {
 	rtest.OK(t, err)
 
 	for _, testBlob := range tests {
-		list := idx.Lookup(testBlob.id, testBlob.tpe, nil)
+		list := idx.Lookup(testBlob.BlobHandle, nil)
 		if len(list) != 1 {
-			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list), list)
+			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.ID.Str(), len(list), list)
 		}
 		result := list[0]
 
-		rtest.Equals(t, testBlob.pack, result.PackID)
-		rtest.Equals(t, testBlob.tpe, result.Type)
-		rtest.Equals(t, testBlob.offset, result.Offset)
-		rtest.Equals(t, testBlob.length, result.Length)
+		rtest.Equals(t, testBlob, result)
 
-		list2 := idx2.Lookup(testBlob.id, testBlob.tpe, nil)
+		list2 := idx2.Lookup(testBlob.BlobHandle, nil)
 		if len(list2) != 1 {
-			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list2), list2)
+			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.ID.Str(), len(list2), list2)
 		}
 		result2 := list2[0]
 
-		rtest.Equals(t, testBlob.pack, result2.PackID)
-		rtest.Equals(t, testBlob.tpe, result2.Type)
-		rtest.Equals(t, testBlob.offset, result2.Offset)
-		rtest.Equals(t, testBlob.length, result2.Length)
+		rtest.Equals(t, testBlob, result2)
 	}
 
 	// add more blobs to idx
-	newtests := []testEntry{}
+	newtests := []restic.PackedBlob{}
 	for i := 0; i < 10; i++ {
 		packID := restic.NewRandomID()
 
 		pos := uint(0)
 		for j := 0; j < 10; j++ {
-			id := restic.NewRandomID()
 			length := uint(i*100 + j)
-			idx.Store(restic.PackedBlob{
+			pb := restic.PackedBlob{
 				Blob: restic.Blob{
-					BlobHandle: restic.BlobHandle{
-						Type: restic.DataBlob,
-						ID:   id,
-					},
-					Offset: pos,
-					Length: length,
+					BlobHandle: restic.NewRandomBlobHandle(),
+					Offset:     pos,
+					Length:     length,
 				},
 				PackID: packID,
-			})
-
-			newtests = append(newtests, testEntry{
-				id:     id,
-				pack:   packID,
-				tpe:    restic.DataBlob,
-				offset: pos,
-				length: length,
-			})
-
+			}
+			idx.Store(pb)
+			newtests = append(newtests, pb)
 			pos += length
 		}
 	}
@@ -154,17 +120,14 @@ func TestIndexSerialize(t *testing.T) {
 
 	// all new blobs must be in the index
 	for _, testBlob := range newtests {
-		list := idx3.Lookup(testBlob.id, testBlob.tpe, nil)
+		list := idx3.Lookup(testBlob.BlobHandle, nil)
 		if len(list) != 1 {
-			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list), list)
+			t.Errorf("expected one result for blob %v, got %v: %v", testBlob.ID.Str(), len(list), list)
 		}
 
 		blob := list[0]
 
-		rtest.Equals(t, testBlob.pack, blob.PackID)
-		rtest.Equals(t, testBlob.tpe, blob.Type)
-		rtest.Equals(t, testBlob.offset, blob.Offset)
-		rtest.Equals(t, testBlob.length, blob.Length)
+		rtest.Equals(t, testBlob, blob)
 	}
 }
 
@@ -178,16 +141,12 @@ func TestIndexSize(t *testing.T) {
 
 		pos := uint(0)
 		for j := 0; j < blobs; j++ {
-			id := restic.NewRandomID()
 			length := uint(i*100 + j)
 			idx.Store(restic.PackedBlob{
 				Blob: restic.Blob{
-					BlobHandle: restic.BlobHandle{
-						Type: restic.DataBlob,
-						ID:   id,
-					},
-					Offset: pos,
-					Length: length,
+					BlobHandle: restic.NewRandomBlobHandle(),
+					Offset:     pos,
+					Length:     length,
 				},
 				PackID: packID,
 			})
@@ -302,7 +261,7 @@ func TestIndexUnserialize(t *testing.T) {
 	rtest.Assert(t, !oldFormat, "new index format recognized as old format")
 
 	for _, test := range exampleTests {
-		list := idx.Lookup(test.id, test.tpe, nil)
+		list := idx.Lookup(restic.BlobHandle{ID: test.id, Type: test.tpe}, nil)
 		if len(list) != 1 {
 			t.Errorf("expected one result for blob %v, got %v: %v", test.id.Str(), len(list), list)
 		}
@@ -378,7 +337,7 @@ func TestIndexUnserializeOld(t *testing.T) {
 	rtest.Assert(t, oldFormat, "old index format recognized as new format")
 
 	for _, test := range exampleTests {
-		list := idx.Lookup(test.id, test.tpe, nil)
+		list := idx.Lookup(restic.BlobHandle{ID: test.id, Type: test.tpe}, nil)
 		if len(list) != 1 {
 			t.Errorf("expected one result for blob %v, got %v: %v", test.id.Str(), len(list), list)
 		}
@@ -401,12 +360,9 @@ func TestIndexPacks(t *testing.T) {
 		packID := restic.NewRandomID()
 		idx.Store(restic.PackedBlob{
 			Blob: restic.Blob{
-				BlobHandle: restic.BlobHandle{
-					Type: restic.DataBlob,
-					ID:   restic.NewRandomID(),
-				},
-				Offset: 0,
-				Length: 23,
+				BlobHandle: restic.NewRandomBlobHandle(),
+				Offset:     0,
+				Length:     23,
 			},
 			PackID: packID,
 		})
@@ -427,7 +383,7 @@ func NewRandomTestID(rng *rand.Rand) restic.ID {
 	return id
 }
 
-func createRandomIndex(rng *rand.Rand, packfiles int) (idx *repository.Index, lookupID restic.ID) {
+func createRandomIndex(rng *rand.Rand, packfiles int) (idx *repository.Index, lookupBh restic.BlobHandle) {
 	idx = repository.NewIndex()
 
 	// create index with given number of pack files
@@ -452,31 +408,34 @@ func createRandomIndex(rng *rand.Rand, packfiles int) (idx *repository.Index, lo
 		idx.StorePack(packID, blobs)
 
 		if i == 0 {
-			lookupID = blobs[rng.Intn(len(blobs))].ID
+			lookupBh = restic.BlobHandle{
+				Type: restic.DataBlob,
+				ID:   blobs[rng.Intn(len(blobs))].ID,
+			}
 		}
 	}
 
-	return idx, lookupID
+	return idx, lookupBh
 }
 
 func BenchmarkIndexHasUnknown(b *testing.B) {
 	idx, _ := createRandomIndex(rand.New(rand.NewSource(0)), 200000)
-	lookupID := restic.NewRandomID()
+	lookupBh := restic.NewRandomBlobHandle()
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		idx.Has(lookupID, restic.DataBlob)
+		idx.Has(lookupBh)
 	}
 }
 
 func BenchmarkIndexHasKnown(b *testing.B) {
-	idx, lookupID := createRandomIndex(rand.New(rand.NewSource(0)), 200000)
+	idx, lookupBh := createRandomIndex(rand.New(rand.NewSource(0)), 200000)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		idx.Has(lookupID, restic.DataBlob)
+		idx.Has(lookupBh)
 	}
 }
 
@@ -501,13 +460,7 @@ func BenchmarkIndexAllocParallel(b *testing.B) {
 }
 
 func TestIndexHas(t *testing.T) {
-	type testEntry struct {
-		id             restic.ID
-		pack           restic.ID
-		tpe            restic.BlobType
-		offset, length uint
-	}
-	tests := []testEntry{}
+	tests := []restic.PackedBlob{}
 
 	idx := repository.NewIndex()
 
@@ -517,36 +470,25 @@ func TestIndexHas(t *testing.T) {
 
 		pos := uint(0)
 		for j := 0; j < 20; j++ {
-			id := restic.NewRandomID()
 			length := uint(i*100 + j)
-			idx.Store(restic.PackedBlob{
+			pb := restic.PackedBlob{
 				Blob: restic.Blob{
-					BlobHandle: restic.BlobHandle{
-						Type: restic.DataBlob,
-						ID:   id,
-					},
-					Offset: pos,
-					Length: length,
+					BlobHandle: restic.NewRandomBlobHandle(),
+					Offset:     pos,
+					Length:     length,
 				},
 				PackID: packID,
-			})
-
-			tests = append(tests, testEntry{
-				id:     id,
-				pack:   packID,
-				tpe:    restic.DataBlob,
-				offset: pos,
-				length: length,
-			})
-
+			}
+			idx.Store(pb)
+			tests = append(tests, pb)
 			pos += length
 		}
 	}
 
 	for _, testBlob := range tests {
-		rtest.Assert(t, idx.Has(testBlob.id, testBlob.tpe), "Index reports not having data blob added to it")
+		rtest.Assert(t, idx.Has(testBlob.BlobHandle), "Index reports not having data blob added to it")
 	}
 
-	rtest.Assert(t, !idx.Has(restic.NewRandomID(), restic.DataBlob), "Index reports having a data blob not added to it")
-	rtest.Assert(t, !idx.Has(tests[0].id, restic.TreeBlob), "Index reports having a tree blob added to it with the same id as a data blob")
+	rtest.Assert(t, !idx.Has(restic.NewRandomBlobHandle()), "Index reports having a data blob not added to it")
+	rtest.Assert(t, !idx.Has(restic.BlobHandle{ID: tests[0].ID, Type: restic.TreeBlob}), "Index reports having a tree blob added to it with the same id as a data blob")
 }

internal/repository/master_index.go

@@ -29,24 +29,24 @@ func NewMasterIndex() *MasterIndex {
 }
 
 // Lookup queries all known Indexes for the ID and returns all matches.
-func (mi *MasterIndex) Lookup(id restic.ID, t restic.BlobType) (pbs []restic.PackedBlob) {
+func (mi *MasterIndex) Lookup(bh restic.BlobHandle) (pbs []restic.PackedBlob) {
 	mi.idxMutex.RLock()
 	defer mi.idxMutex.RUnlock()
 
 	for _, idx := range mi.idx {
-		pbs = idx.Lookup(id, t, pbs)
+		pbs = idx.Lookup(bh, pbs)
 	}
 
 	return pbs
 }
 
 // LookupSize queries all known Indexes for the ID and returns the first match.
-func (mi *MasterIndex) LookupSize(id restic.ID, t restic.BlobType) (uint, bool) {
+func (mi *MasterIndex) LookupSize(bh restic.BlobHandle) (uint, bool) {
 	mi.idxMutex.RLock()
 	defer mi.idxMutex.RUnlock()
 
 	for _, idx := range mi.idx {
-		if size, found := idx.LookupSize(id, t); found {
+		if size, found := idx.LookupSize(bh); found {
 			return size, found
 		}
 	}
@@ -58,40 +58,40 @@ func (mi *MasterIndex) LookupSize(id restic.ID, t restic.BlobType) (uint, bool)
 // Before doing so it checks if this blob is already known.
 // Returns true if adding was successful and false if the blob
 // was already known
-func (mi *MasterIndex) addPending(id restic.ID, t restic.BlobType) bool {
+func (mi *MasterIndex) addPending(bh restic.BlobHandle) bool {
 
 	mi.idxMutex.Lock()
 	defer mi.idxMutex.Unlock()
 
 	// Check if blob is pending or in index
-	if mi.pendingBlobs.Has(restic.BlobHandle{ID: id, Type: t}) {
+	if mi.pendingBlobs.Has(bh) {
 		return false
 	}
 
 	for _, idx := range mi.idx {
-		if idx.Has(id, t) {
+		if idx.Has(bh) {
 			return false
 		}
 	}
 
 	// really not known -> insert
-	mi.pendingBlobs.Insert(restic.BlobHandle{ID: id, Type: t})
+	mi.pendingBlobs.Insert(bh)
 	return true
 }
 
 // Has queries all known Indexes for the ID and returns the first match.
 // Also returns true if the ID is pending.
-func (mi *MasterIndex) Has(id restic.ID, t restic.BlobType) bool {
+func (mi *MasterIndex) Has(bh restic.BlobHandle) bool {
 	mi.idxMutex.RLock()
 	defer mi.idxMutex.RUnlock()
 
 	// also return true if blob is pending
-	if mi.pendingBlobs.Has(restic.BlobHandle{ID: id, Type: t}) {
+	if mi.pendingBlobs.Has(bh) {
 		return true
 	}
 
 	for _, idx := range mi.idx {
-		if idx.Has(id, t) {
+		if idx.Has(bh) {
 			return true
 		}
 	}

internal/repository/master_index_test.go

@@ -14,55 +14,43 @@ import (
 )
 
 func TestMasterIndex(t *testing.T) {
-	idInIdx1 := restic.NewRandomID()
-	idInIdx2 := restic.NewRandomID()
-	idInIdx12 := restic.NewRandomID()
+	bhInIdx1 := restic.NewRandomBlobHandle()
+	bhInIdx2 := restic.NewRandomBlobHandle()
+	bhInIdx12 := restic.BlobHandle{ID: restic.NewRandomID(), Type: restic.TreeBlob}
 
 	blob1 := restic.PackedBlob{
 		PackID: restic.NewRandomID(),
 		Blob: restic.Blob{
-			BlobHandle: restic.BlobHandle{
-				Type: restic.DataBlob,
-				ID:   idInIdx1,
-			},
-			Length: uint(restic.CiphertextLength(10)),
-			Offset: 0,
+			BlobHandle: bhInIdx1,
+			Length:     uint(restic.CiphertextLength(10)),
+			Offset:     0,
 		},
 	}
 
 	blob2 := restic.PackedBlob{
 		PackID: restic.NewRandomID(),
 		Blob: restic.Blob{
-			BlobHandle: restic.BlobHandle{
-				Type: restic.DataBlob,
-				ID:   idInIdx2,
-			},
-			Length: uint(restic.CiphertextLength(100)),
-			Offset: 10,
+			BlobHandle: bhInIdx2,
+			Length:     uint(restic.CiphertextLength(100)),
+			Offset:     10,
 		},
 	}
 
 	blob12a := restic.PackedBlob{
 		PackID: restic.NewRandomID(),
 		Blob: restic.Blob{
-			BlobHandle: restic.BlobHandle{
-				Type: restic.TreeBlob,
-				ID:   idInIdx12,
-			},
-			Length: uint(restic.CiphertextLength(123)),
-			Offset: 110,
+			BlobHandle: bhInIdx12,
+			Length:     uint(restic.CiphertextLength(123)),
+			Offset:     110,
 		},
 	}
 
 	blob12b := restic.PackedBlob{
 		PackID: restic.NewRandomID(),
 		Blob: restic.Blob{
-			BlobHandle: restic.BlobHandle{
-				Type: restic.TreeBlob,
-				ID:   idInIdx12,
-			},
-			Length: uint(restic.CiphertextLength(123)),
-			Offset: 50,
+			BlobHandle: bhInIdx12,
+			Length:     uint(restic.CiphertextLength(123)),
+			Offset:     50,
 		},
 	}
 
@@ -79,32 +67,32 @@ func TestMasterIndex(t *testing.T) {
 	mIdx.Insert(idx2)
 
 	// test idInIdx1
-	found := mIdx.Has(idInIdx1, restic.DataBlob)
+	found := mIdx.Has(bhInIdx1)
 	rtest.Equals(t, true, found)
 
-	blobs := mIdx.Lookup(idInIdx1, restic.DataBlob)
+	blobs := mIdx.Lookup(bhInIdx1)
 	rtest.Equals(t, []restic.PackedBlob{blob1}, blobs)
 
-	size, found := mIdx.LookupSize(idInIdx1, restic.DataBlob)
+	size, found := mIdx.LookupSize(bhInIdx1)
 	rtest.Equals(t, true, found)
 	rtest.Equals(t, uint(10), size)
 
 	// test idInIdx2
-	found = mIdx.Has(idInIdx2, restic.DataBlob)
+	found = mIdx.Has(bhInIdx2)
 	rtest.Equals(t, true, found)
 
-	blobs = mIdx.Lookup(idInIdx2, restic.DataBlob)
+	blobs = mIdx.Lookup(bhInIdx2)
 	rtest.Equals(t, []restic.PackedBlob{blob2}, blobs)
 
-	size, found = mIdx.LookupSize(idInIdx2, restic.DataBlob)
+	size, found = mIdx.LookupSize(bhInIdx2)
 	rtest.Equals(t, true, found)
 	rtest.Equals(t, uint(100), size)
 
 	// test idInIdx12
-	found = mIdx.Has(idInIdx12, restic.TreeBlob)
+	found = mIdx.Has(bhInIdx12)
 	rtest.Equals(t, true, found)
 
-	blobs = mIdx.Lookup(idInIdx12, restic.TreeBlob)
+	blobs = mIdx.Lookup(bhInIdx12)
 	rtest.Equals(t, 2, len(blobs))
 
 	// test Lookup result for blob12a
@@ -121,16 +109,16 @@ func TestMasterIndex(t *testing.T) {
 	}
 	rtest.Assert(t, found, "blob12a not found in result")
 
-	size, found = mIdx.LookupSize(idInIdx12, restic.TreeBlob)
+	size, found = mIdx.LookupSize(bhInIdx12)
 	rtest.Equals(t, true, found)
 	rtest.Equals(t, uint(123), size)
 
 	// test not in index
-	found = mIdx.Has(restic.NewRandomID(), restic.TreeBlob)
+	found = mIdx.Has(restic.BlobHandle{ID: restic.NewRandomID(), Type: restic.TreeBlob})
 	rtest.Assert(t, !found, "Expected no blobs when fetching with a random id")
-	blobs = mIdx.Lookup(restic.NewRandomID(), restic.DataBlob)
+	blobs = mIdx.Lookup(restic.NewRandomBlobHandle())
 	rtest.Assert(t, blobs == nil, "Expected no blobs when fetching with a random id")
-	_, found = mIdx.LookupSize(restic.NewRandomID(), restic.DataBlob)
+	_, found = mIdx.LookupSize(restic.NewRandomBlobHandle())
 	rtest.Assert(t, !found, "Expected no blobs when fetching with a random id")
 
 	// Test Count
@@ -141,30 +129,24 @@ func TestMasterIndex(t *testing.T) {
 }
 
 func TestMasterMergeFinalIndexes(t *testing.T) {
-	idInIdx1 := restic.NewRandomID()
-	idInIdx2 := restic.NewRandomID()
+	bhInIdx1 := restic.NewRandomBlobHandle()
+	bhInIdx2 := restic.NewRandomBlobHandle()
 
 	blob1 := restic.PackedBlob{
 		PackID: restic.NewRandomID(),
 		Blob: restic.Blob{
-			BlobHandle: restic.BlobHandle{
-				Type: restic.DataBlob,
-				ID:   idInIdx1,
-			},
-			Length: 10,
-			Offset: 0,
+			BlobHandle: bhInIdx1,
+			Length:     10,
+			Offset:     0,
 		},
 	}
 
 	blob2 := restic.PackedBlob{
 		PackID: restic.NewRandomID(),
 		Blob: restic.Blob{
-			BlobHandle: restic.BlobHandle{
-				Type: restic.DataBlob,
-				ID:   idInIdx2,
-			},
-			Length: 100,
-			Offset: 10,
+			BlobHandle: bhInIdx2,
+			Length:     100,
+			Offset:     10,
 		},
 	}
 
@@ -191,13 +173,13 @@ func TestMasterMergeFinalIndexes(t *testing.T) {
 	}
 	rtest.Equals(t, 2, blobCount)
 
-	blobs := mIdx.Lookup(idInIdx1, restic.DataBlob)
+	blobs := mIdx.Lookup(bhInIdx1)
 	rtest.Equals(t, []restic.PackedBlob{blob1}, blobs)
 
-	blobs = mIdx.Lookup(idInIdx2, restic.DataBlob)
+	blobs = mIdx.Lookup(bhInIdx2)
 	rtest.Equals(t, []restic.PackedBlob{blob2}, blobs)
 
-	blobs = mIdx.Lookup(restic.NewRandomID(), restic.DataBlob)
+	blobs = mIdx.Lookup(restic.NewRandomBlobHandle())
 	rtest.Assert(t, blobs == nil, "Expected no blobs when fetching with a random id")
 
 	// merge another index containing identical blobs
@@ -214,10 +196,10 @@ func TestMasterMergeFinalIndexes(t *testing.T) {
 	rtest.Equals(t, 1, len(allIndexes))
 
 	// Index should have same entries as before!
-	blobs = mIdx.Lookup(idInIdx1, restic.DataBlob)
+	blobs = mIdx.Lookup(bhInIdx1)
 	rtest.Equals(t, []restic.PackedBlob{blob1}, blobs)
 
-	blobs = mIdx.Lookup(idInIdx2, restic.DataBlob)
+	blobs = mIdx.Lookup(bhInIdx2)
 	rtest.Equals(t, []restic.PackedBlob{blob2}, blobs)
 
 	blobCount = 0
@@ -227,19 +209,19 @@ func TestMasterMergeFinalIndexes(t *testing.T) {
 	rtest.Equals(t, 2, blobCount)
 }
 
-func createRandomMasterIndex(rng *rand.Rand, num, size int) (*repository.MasterIndex, restic.ID) {
+func createRandomMasterIndex(rng *rand.Rand, num, size int) (*repository.MasterIndex, restic.BlobHandle) {
 	mIdx := repository.NewMasterIndex()
 	for i := 0; i < num-1; i++ {
 		idx, _ := createRandomIndex(rng, size)
 		mIdx.Insert(idx)
 	}
-	idx1, lookupID := createRandomIndex(rng, size)
+	idx1, lookupBh := createRandomIndex(rng, size)
 	mIdx.Insert(idx1)
 
 	mIdx.FinalizeNotFinalIndexes()
 	mIdx.MergeFinalIndexes()
 
-	return mIdx, lookupID
+	return mIdx, lookupBh
 }
 
 func BenchmarkMasterIndexAlloc(b *testing.B) {
@@ -252,45 +234,45 @@ func BenchmarkMasterIndexAlloc(b *testing.B) {
 }
 
 func BenchmarkMasterIndexLookupSingleIndex(b *testing.B) {
-	mIdx, lookupID := createRandomMasterIndex(rand.New(rand.NewSource(0)), 1, 200000)
+	mIdx, lookupBh := createRandomMasterIndex(rand.New(rand.NewSource(0)), 1, 200000)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		mIdx.Lookup(lookupID, restic.DataBlob)
+		mIdx.Lookup(lookupBh)
 	}
 }
 
 func BenchmarkMasterIndexLookupMultipleIndex(b *testing.B) {
-	mIdx, lookupID := createRandomMasterIndex(rand.New(rand.NewSource(0)), 100, 10000)
+	mIdx, lookupBh := createRandomMasterIndex(rand.New(rand.NewSource(0)), 100, 10000)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		mIdx.Lookup(lookupID, restic.DataBlob)
+		mIdx.Lookup(lookupBh)
 	}
 }
 
 func BenchmarkMasterIndexLookupSingleIndexUnknown(b *testing.B) {
 
-	lookupID := restic.NewRandomID()
+	lookupBh := restic.NewRandomBlobHandle()
 	mIdx, _ := createRandomMasterIndex(rand.New(rand.NewSource(0)), 1, 200000)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		mIdx.Lookup(lookupID, restic.DataBlob)
+		mIdx.Lookup(lookupBh)
 	}
 }
 
 func BenchmarkMasterIndexLookupMultipleIndexUnknown(b *testing.B) {
-	lookupID := restic.NewRandomID()
+	lookupBh := restic.NewRandomBlobHandle()
 	mIdx, _ := createRandomMasterIndex(rand.New(rand.NewSource(0)), 100, 10000)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		mIdx.Lookup(lookupID, restic.DataBlob)
+		mIdx.Lookup(lookupBh)
 	}
 }
 
@@ -298,28 +280,28 @@ func BenchmarkMasterIndexLookupParallel(b *testing.B) {
 	mIdx := repository.NewMasterIndex()
 
 	for _, numindices := range []int{25, 50, 100} {
-		var lookupID restic.ID
+		var lookupBh restic.BlobHandle
 
 		b.StopTimer()
 		rng := rand.New(rand.NewSource(0))
-		mIdx, lookupID = createRandomMasterIndex(rng, numindices, 10000)
+		mIdx, lookupBh = createRandomMasterIndex(rng, numindices, 10000)
 		b.StartTimer()
 
 		name := fmt.Sprintf("known,indices=%d", numindices)
 		b.Run(name, func(b *testing.B) {
 			b.RunParallel(func(pb *testing.PB) {
 				for pb.Next() {
-					mIdx.Lookup(lookupID, restic.DataBlob)
+					mIdx.Lookup(lookupBh)
 				}
 			})
 		})
 
-		lookupID = restic.NewRandomID()
+		lookupBh = restic.NewRandomBlobHandle()
 		name = fmt.Sprintf("unknown,indices=%d", numindices)
 		b.Run(name, func(b *testing.B) {
 			b.RunParallel(func(pb *testing.PB) {
 				for pb.Next() {
-					mIdx.Lookup(lookupID, restic.DataBlob)
+					mIdx.Lookup(lookupBh)
 				}
 			})
 		})
@@ -328,12 +310,12 @@ func BenchmarkMasterIndexLookupParallel(b *testing.B) {
 
 func BenchmarkMasterIndexLookupBlobSize(b *testing.B) {
 	rng := rand.New(rand.NewSource(0))
-	mIdx, lookupID := createRandomMasterIndex(rand.New(rng), 5, 200000)
+	mIdx, lookupBh := createRandomMasterIndex(rand.New(rng), 5, 200000)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		mIdx.LookupSize(lookupID, restic.DataBlob)
+		mIdx.LookupSize(lookupBh)
 	}
 }
 

internal/repository/repack_test.go

@@ -128,7 +128,7 @@ func findPacksForBlobs(t *testing.T, repo restic.Repository, blobs restic.BlobSe
 
 	idx := repo.Index()
 	for h := range blobs {
-		list := idx.Lookup(h.ID, h.Type)
+		list := idx.Lookup(h)
 		if len(list) == 0 {
 			t.Fatal("Failed to find blob", h.ID.Str(), "with type", h.Type)
 		}
@@ -249,7 +249,7 @@ func TestRepack(t *testing.T) {
 	idx := repo.Index()
 
 	for h := range keepBlobs {
-		list := idx.Lookup(h.ID, h.Type)
+		list := idx.Lookup(h)
 		if len(list) == 0 {
 			t.Errorf("unable to find blob %v in repo", h.ID.Str())
 			continue

internal/repository/repository.go

@@ -152,7 +152,7 @@ func (r *Repository) LoadBlob(ctx context.Context, t restic.BlobType, id restic.
 	debug.Log("load %v with id %v (buf len %v, cap %d)", t, id, len(buf), cap(buf))
 
 	// lookup packs
-	blobs := r.idx.Lookup(id, t)
+	blobs := r.idx.Lookup(restic.BlobHandle{ID: id, Type: t})
 	if len(blobs) == 0 {
 		debug.Log("id %v not found in index", id)
 		return nil, errors.Errorf("id %v not found in repository", id)
@@ -232,7 +232,7 @@ func (r *Repository) LoadJSONUnpacked(ctx context.Context, t restic.FileType, id
 
 // LookupBlobSize returns the size of blob id.
 func (r *Repository) LookupBlobSize(id restic.ID, tpe restic.BlobType) (uint, bool) {
-	return r.idx.LookupSize(id, tpe)
+	return r.idx.LookupSize(restic.BlobHandle{ID: id, Type: tpe})
 }
 
 // SaveAndEncrypt encrypts data and stores it to the backend as type t. If data
@@ -773,7 +773,7 @@ func (r *Repository) SaveBlob(ctx context.Context, t restic.BlobType, buf []byte
 	}
 
 	// first try to add to pending blobs; if not successful, this blob is already known
-	known = !r.idx.addPending(newID, t)
+	known = !r.idx.addPending(restic.BlobHandle{ID: newID, Type: t})
 
 	// only save when needed or explicitly told
 	if !known || storeDuplicate {

internal/repository/repository_test.go

@@ -296,12 +296,9 @@ func BenchmarkLoadIndex(b *testing.B) {
 	for i := 0; i < 5000; i++ {
 		idx.Store(restic.PackedBlob{
 			Blob: restic.Blob{
-				BlobHandle: restic.BlobHandle{
-					Type: restic.DataBlob,
-					ID:   restic.NewRandomID(),
-				},
-				Length: 1234,
-				Offset: 1235,
+				BlobHandle: restic.NewRandomBlobHandle(),
+				Length:     1234,
+				Offset:     1235,
 			},
 			PackID: restic.NewRandomID(),
 		})