retention

type Chunk struct {
	ChunkID string
	From    model.Time
	Through model.Time
}

type ChunkClient interface {
	DeleteChunk(ctx context.Context, userID, chunkID string) error
	IsChunkNotFoundErr(err error) bool
}

type ExpirationChecker interface {
	Expired(userID []byte, chk Chunk, lbls labels.Labels, seriesID []byte, tableName string, now model.Time) (bool, filter.Func)
	IntervalMayHaveExpiredChunks(interval model.Interval, userID string) bool
	MarkPhaseStarted()
	MarkPhaseFailed()
	MarkPhaseTimedOut()
	MarkPhaseFinished()
	DropFromIndex(userID []byte, chk Chunk, labels labels.Labels, tableEndTime model.Time, now model.Time) bool
	CanSkipSeries(userID []byte, lbls labels.Labels, seriesID []byte, seriesStart model.Time, tableName string, now model.Time) bool
	MarkSeriesAsProcessed(userID, seriesID []byte, lbls labels.Labels, tableName string) error
}

type IndexCleaner interface {
	RemoveChunk(from, through model.Time, userID []byte, labels labels.Labels, chunkID string) (bool, error)
	// CleanupSeries is for cleaning up the series that do have any chunks left in the index.
	// It would only be called for the series that have all their chunks deleted without adding new ones.
	CleanupSeries(userID []byte, lbls labels.Labels) error
}

type IndexProcessor interface {
	SeriesIterator

	IndexCleaner
	ChunkExists(userID []byte, lbls labels.Labels, chunkRef logproto.ChunkRef) (bool, error)
	// contains filtered or unexported methods
}

type IntervalFilter struct {
	Interval model.Interval
	Filter   filter.Func
}

type Limits interface {
	RetentionPeriod(userID string) time.Duration
	StreamRetention(userID string) []validation.StreamRetention
	AllByUserID() map[string]*validation.Limits
	DefaultLimits() *validation.Limits
	PoliciesStreamMapping(userID string) validation.PolicyStreamMapping
}

type Marker struct {
	// contains filtered or unexported fields
}

type MarkerProcessor interface {
	// Start starts parsing marks and calling deleteFunc for each.
	// If deleteFunc returns no error the mark is deleted from the storage.
	// Otherwise the mark will reappears in future iteration.
	Start(deleteFunc func(ctx context.Context, chunkId []byte) error)
	// Stop stops processing marks.
	Stop()
}

type MarkerStorageWriter interface {
	Put(chunkID []byte) error
	Count() int64
	Close() error
}

type Series interface {
	SeriesID() []byte
	UserID() []byte
	Labels() labels.Labels
	Chunks() []Chunk
	Reset(seriesID, userID []byte, labels labels.Labels)
	AppendChunks(ref ...Chunk)
}

type SeriesCallback func(series Series) (err error)

type SeriesIterator interface {
	ForEachSeries(ctx context.Context, callback SeriesCallback) error
}

type Sweeper struct {
	// contains filtered or unexported fields
}

type TableMarker interface {
	// FindAndMarkChunksForDeletion marks chunks to delete for a given table and returns if it's empty or modified.
	FindAndMarkChunksForDeletion(ctx context.Context, tableName, userID string, indexProcessor IndexProcessor, logger log.Logger) (bool, bool, error)

	// MarkChunksForDeletion marks the given list of chunks for deletion
	MarkChunksForDeletion(tableName string, chunks []string) error
}

type TenantRetentionSnapshot struct {
	// contains filtered or unexported fields
}

type TenantsRetention struct {
	// contains filtered or unexported fields
}