prometheus/block.go

218 lines
4.6 KiB
Go
Raw Normal View History

package tsdb
2016-12-15 07:31:26 +00:00
import (
"encoding/json"
"io/ioutil"
2016-12-15 07:31:26 +00:00
"os"
"path/filepath"
"sort"
2016-12-22 14:54:39 +00:00
2017-02-27 09:46:15 +00:00
"github.com/oklog/ulid"
2016-12-22 14:54:39 +00:00
"github.com/pkg/errors"
)
// Block handles reads against a Block of time series data.
type Block interface {
// Directory where block data is stored.
Dir() string
// Stats returns statistics about the block.
Meta() BlockMeta
// Index returns an IndexReader over the block's data.
Index() IndexReader
// Series returns a SeriesReader over the block's data.
Chunks() ChunkReader
// Close releases all underlying resources of the block.
2017-01-18 05:18:32 +00:00
Close() error
2016-12-13 14:26:58 +00:00
}
// BlockMeta provides meta information about a block.
type BlockMeta struct {
2017-02-27 09:46:15 +00:00
// Unique identifier for the block and its contents. Changes on compaction.
ULID ulid.ULID `json:"ulid"`
// Sequence number of the block.
Sequence int `json:"sequence"`
2017-01-19 13:01:38 +00:00
// MinTime and MaxTime specify the time range all samples
// in the block are in.
MinTime int64 `json:"minTime"`
MaxTime int64 `json:"maxTime"`
2017-01-07 17:02:17 +00:00
// Stats about the contents of the block.
Stats struct {
NumSamples uint64 `json:"numSamples,omitempty"`
NumSeries uint64 `json:"numSeries,omitempty"`
NumChunks uint64 `json:"numChunks,omitempty"`
} `json:"stats,omitempty"`
2017-01-19 18:45:52 +00:00
// Information on compactions the block was created from.
2017-01-19 18:45:52 +00:00
Compaction struct {
Generation int `json:"generation"`
} `json:"compaction"`
}
const (
flagNone = 0
flagStd = 1
)
2016-12-15 07:31:26 +00:00
type persistedBlock struct {
dir string
meta BlockMeta
2017-01-03 09:09:20 +00:00
chunkr *chunkReader
indexr *indexReader
2016-12-15 07:31:26 +00:00
}
type blockMeta struct {
2017-01-19 13:01:38 +00:00
Version int `json:"version"`
*BlockMeta
}
const metaFilename = "meta.json"
2017-01-19 13:01:38 +00:00
func readMetaFile(dir string) (*BlockMeta, error) {
b, err := ioutil.ReadFile(filepath.Join(dir, metaFilename))
if err != nil {
return nil, err
}
var m blockMeta
if err := json.Unmarshal(b, &m); err != nil {
return nil, err
}
if m.Version != 1 {
return nil, errors.Errorf("unexpected meta file version %d", m.Version)
}
return m.BlockMeta, nil
}
func writeMetaFile(dir string, meta *BlockMeta) error {
2017-03-01 16:19:57 +00:00
// Make any changes to the file appear atomic.
path := filepath.Join(dir, metaFilename)
tmp := path + ".tmp"
f, err := os.Create(tmp)
2017-01-19 13:01:38 +00:00
if err != nil {
return err
}
enc := json.NewEncoder(f)
enc.SetIndent("", "\t")
if err := enc.Encode(&blockMeta{Version: 1, BlockMeta: meta}); err != nil {
return err
}
if err := f.Close(); err != nil {
return err
}
2017-03-01 16:19:57 +00:00
return renameFile(tmp, path)
2017-01-19 13:01:38 +00:00
}
func newPersistedBlock(dir string) (*persistedBlock, error) {
2017-01-19 18:45:52 +00:00
meta, err := readMetaFile(dir)
if err != nil {
return nil, err
}
2016-12-15 07:31:26 +00:00
2017-02-27 09:46:15 +00:00
cr, err := newChunkReader(chunkDir(dir))
2016-12-15 07:31:26 +00:00
if err != nil {
return nil, err
2016-12-15 07:31:26 +00:00
}
ir, err := newIndexReader(dir)
2016-12-15 07:31:26 +00:00
if err != nil {
return nil, err
2016-12-15 07:31:26 +00:00
}
pb := &persistedBlock{
dir: dir,
meta: *meta,
chunkr: cr,
indexr: ir,
2016-12-15 07:31:26 +00:00
}
return pb, nil
}
func (pb *persistedBlock) Close() error {
2017-02-27 09:46:15 +00:00
var merr MultiError
2016-12-15 07:31:26 +00:00
2017-02-27 09:46:15 +00:00
merr.Add(pb.chunkr.Close())
merr.Add(pb.indexr.Close())
return merr.Err()
2016-12-15 07:31:26 +00:00
}
func (pb *persistedBlock) Dir() string { return pb.dir }
func (pb *persistedBlock) Index() IndexReader { return pb.indexr }
func (pb *persistedBlock) Chunks() ChunkReader { return pb.chunkr }
func (pb *persistedBlock) Meta() BlockMeta { return pb.meta }
2017-02-27 09:46:15 +00:00
func chunkDir(dir string) string { return filepath.Join(dir, "chunks") }
func walDir(dir string) string { return filepath.Join(dir, "wal") }
2016-12-15 07:31:26 +00:00
type mmapFile struct {
f *os.File
2016-12-15 07:31:26 +00:00
b []byte
}
func openMmapFile(path string) (*mmapFile, error) {
f, err := os.Open(path)
2016-12-15 07:31:26 +00:00
if err != nil {
return nil, errors.Wrap(err, "try lock file")
2016-12-15 07:31:26 +00:00
}
info, err := f.Stat()
if err != nil {
return nil, errors.Wrap(err, "stat")
2016-12-15 07:31:26 +00:00
}
b, err := mmap(f, int(info.Size()))
2016-12-15 07:31:26 +00:00
if err != nil {
return nil, errors.Wrap(err, "mmap")
2016-12-15 07:31:26 +00:00
}
return &mmapFile{f: f, b: b}, nil
}
func (f *mmapFile) Close() error {
err0 := munmap(f.b)
err1 := f.f.Close()
if err0 != nil {
return err0
}
return err1
}
// A skiplist maps offsets to values. The values found in the data at an
// offset are strictly greater than the indexed value.
type skiplist interface {
// offset returns the offset to data containing values of x and lower.
offset(x int64) (uint32, bool)
}
// simpleSkiplist is a slice of plain value/offset pairs.
type simpleSkiplist []skiplistPair
type skiplistPair struct {
value int64
offset uint32
}
func (sl simpleSkiplist) offset(x int64) (uint32, bool) {
// Search for the first offset that contains data greater than x.
i := sort.Search(len(sl), func(i int) bool { return sl[i].value >= x })
// If no element was found return false. If the first element is found,
// there's no previous offset actually containing values that are x or lower.
if i == len(sl) || i == 0 {
return 0, false
}
return sl[i-1].offset, true
}