Don't export MemTombstones.

Signed-off-by: Callum Styan <[email protected]>

Author: cstyan

compact_test.go

@@ -456,10 +456,12 @@ func metaRange(name string, mint, maxt int64, stats *BlockStats) dirMeta {
 
 type erringBReader struct{}
 
-func (erringBReader) Index() (IndexReader, error)          { return nil, errors.New("index") }
-func (erringBReader) Chunks() (ChunkReader, error)         { return nil, errors.New("chunks") }
-func (erringBReader) Tombstones() (TombstoneReader, error) { return nil, errors.New("tombstones") }
-func (erringBReader) Meta() BlockMeta                      { return BlockMeta{} }
+func (erringBReader) Index() (IndexReader, error)  { return nil, errors.New("index") }
+func (erringBReader) Chunks() (ChunkReader, error) { return nil, errors.New("chunks") }
+func (erringBReader) Tombstones() (tombstones.TombstoneReader, error) {
+	return nil, errors.New("tombstones")
+}
+func (erringBReader) Meta() BlockMeta { return BlockMeta{} }
 
 type nopChunkWriter struct{}
 

mocks_test.go

@@ -73,7 +73,9 @@ type mockBReader struct {
 	maxt int64
 }
 
-func (r *mockBReader) Index() (IndexReader, error)          { return r.ir, nil }
-func (r *mockBReader) Chunks() (ChunkReader, error)         { return r.cr, nil }
-func (r *mockBReader) Tombstones() (TombstoneReader, error) { return newMemTombstones(), nil }
-func (r *mockBReader) Meta() BlockMeta                      { return BlockMeta{MinTime: r.mint, MaxTime: r.maxt} }
+func (r *mockBReader) Index() (IndexReader, error)  { return r.ir, nil }
+func (r *mockBReader) Chunks() (ChunkReader, error) { return r.cr, nil }
+func (r *mockBReader) Tombstones() (tombstones.TombstoneReader, error) {
+	return tombstones.NewMemTombstones(), nil
+}
+func (r *mockBReader) Meta() BlockMeta { return BlockMeta{MinTime: r.mint, MaxTime: r.maxt} }

querier_test.go

@@ -413,6 +413,11 @@ func TestBlockQuerierDelete(t *testing.T) {
 		exp        SeriesSet
 	}
 
+	tstones := tombstones.NewMemTombstones()
+	tstones.AddInterval(1, tombstones.Interval{1, 3})
+	tstones.AddInterval(2, tombstones.Interval{1, 3}, tombstones.Interval{6, 10})
+	tstones.AddInterval(3, tombstones.Interval{6, 10})
+
 	cases := struct {
 		data []seriesSamples
 
@@ -461,11 +466,7 @@ func TestBlockQuerierDelete(t *testing.T) {
 				},
 			},
 		},
-		tombstones: &tombstones.MemTombstones{IntvlGroups: map[uint64]tombstones.Intervals{
-			1: tombstones.Intervals{{1, 3}},
-			2: tombstones.Intervals{{1, 3}, {6, 10}},
-			3: tombstones.Intervals{{6, 10}},
-		}},
+		tombstones: tstones,
 		queries: []query{
 			{
 				mint: 2,

tombstones/tombstones.go

@@ -199,51 +199,51 @@ func ReadTombstones(dir string) (TombstoneReader, int64, error) {
 	return stonesMap, int64(len(b)), nil
 }
 
-type MemTombstones struct {
-	IntvlGroups map[uint64]Intervals
+type memTombstones struct {
+	intvlGroups map[uint64]Intervals
 	mtx         sync.RWMutex
 }
 
 // NewMemTombstones creates new in memory TombstoneReader
 // that allows adding new intervals.
-func NewMemTombstones() *MemTombstones {
-	return &MemTombstones{IntvlGroups: make(map[uint64]Intervals)}
+func NewMemTombstones() *memTombstones {
+	return &memTombstones{intvlGroups: make(map[uint64]Intervals)}
 }
 
-func (t *MemTombstones) Get(ref uint64) (Intervals, error) {
+func (t *memTombstones) Get(ref uint64) (Intervals, error) {
 	t.mtx.RLock()
 	defer t.mtx.RUnlock()
-	return t.IntvlGroups[ref], nil
+	return t.intvlGroups[ref], nil
 }
 
-func (t *MemTombstones) Iter(f func(uint64, Intervals) error) error {
+func (t *memTombstones) Iter(f func(uint64, Intervals) error) error {
 	t.mtx.RLock()
 	defer t.mtx.RUnlock()
-	for ref, ivs := range t.IntvlGroups {
+	for ref, ivs := range t.intvlGroups {
 		if err := f(ref, ivs); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (t *MemTombstones) Total() uint64 {
+func (t *memTombstones) Total() uint64 {
 	t.mtx.RLock()
 	defer t.mtx.RUnlock()
 
 	total := uint64(0)
-	for _, ivs := range t.IntvlGroups {
+	for _, ivs := range t.intvlGroups {
 		total += uint64(len(ivs))
 	}
 	return total
 }
 
 // AddInterval to an existing MemTombstones
-func (t *MemTombstones) AddInterval(ref uint64, itvs ...Interval) {
+func (t *memTombstones) AddInterval(ref uint64, itvs ...Interval) {
 	t.mtx.Lock()
 	defer t.mtx.Unlock()
 	for _, itv := range itvs {
-		t.IntvlGroups[ref] = t.IntvlGroups[ref].Add(itv)
+		t.intvlGroups[ref] = t.intvlGroups[ref].Add(itv)
 	}
 }