mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2025-03-05 20:59:13 -08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

use a db copy instead of creating it again.

Browse source 
Signed-off-by: Krasi Georgiev <kgeorgie@redhat.com>
This commit is contained in:
Krasi Georgiev 2019-01-24 14:15:32 +02:00
parent 8ffd705346
commit 1b0d85bbf2
1 changed files with 65 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
compact_test.go
View file

@ -15,7 +15,6 @@ package tsdb
import ( import (
"context" "context"
"fmt"
"io/ioutil" "io/ioutil"
"math" "math"
"os" "os"
@ -28,6 +27,7 @@ import (
prom_testutil "github.com/prometheus/client_golang/prometheus/testutil" prom_testutil "github.com/prometheus/client_golang/prometheus/testutil"
dto "github.com/prometheus/client_model/go" dto "github.com/prometheus/client_model/go"
"github.com/prometheus/tsdb/chunks" "github.com/prometheus/tsdb/chunks"
"github.com/prometheus/tsdb/fileutil"
"github.com/prometheus/tsdb/labels" "github.com/prometheus/tsdb/labels"
"github.com/prometheus/tsdb/testutil" "github.com/prometheus/tsdb/testutil"
) )
@ -748,29 +748,30 @@ func TestDisableAutoCompactions(t *testing.T) {
// TestCancelCompactions ensures that when the db is closed // TestCancelCompactions ensures that when the db is closed
// any running compaction is cancelled to unblock closing the db. // any running compaction is cancelled to unblock closing the db.
func TestCancelCompactions(t *testing.T) { func TestCancelCompactions(t *testing.T) {
createTestDb := func() (*DB, func()) {
tmpdir, err := ioutil.TempDir("", "testCancelCompaction") tmpdir, err := ioutil.TempDir("", "testCancelCompaction")
testutil.Ok(t, err) testutil.Ok(t, err)
defer os.RemoveAll(tmpdir)
// Create some blocks to fall within the compaction range. // Create some blocks to fall within the compaction range.
createBlock(t, tmpdir, 10000, 0, 1000) createBlock(t, tmpdir, 7000, 0, 1000)
createBlock(t, tmpdir, 10000, 1000, 2000) createBlock(t, tmpdir, 7000, 1000, 2000)
createBlock(t, tmpdir, 1, 2000, 2001) // The most recent block is ignored so can be e small one. createBlock(t, tmpdir, 1, 2000, 2001) // The most recent block is ignored so can be e small one.
db, err := Open(tmpdir, log.NewNopLogger(), nil, &Options{BlockRanges: []int64{1, 2000}})
testutil.Ok(t, err)
testutil.Equals(t, 3, len(db.Blocks()), "initial block count mismatch")
testutil.Equals(t, 0.0, prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.ran), "initial compaction counter mismatch")
return db, func() { // Copy the db so we have an exact copy to compare compaction times.
os.RemoveAll(tmpdir) tmpdirCopy := tmpdir + "Copy"
} err = fileutil.CopyDirs(tmpdir, tmpdirCopy)
} testutil.Ok(t, err)
// First lets mesure the compaction time without interupting it. defer os.RemoveAll(tmpdirCopy)
// Measure the compaction time without interupting it.
var timeCompactionUninterrupted time.Duration var timeCompactionUninterrupted time.Duration
{ {
db, delete := createTestDb() db, err := Open(tmpdir, log.NewNopLogger(), nil, &Options{BlockRanges: []int64{1, 2000}})
defer delete() testutil.Ok(t, err)
db.compactc <- struct{}{} // Trigger a compaction. db.DisableCompactions()
testutil.Equals(t, 3, len(db.Blocks()), "initial block count mismatch")
testutil.Equals(t, 0.0, prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.ran), "initial compaction counter mismatch")
go func() {
var start time.Time var start time.Time
for { for {
if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.populatingBlocks) > 0 { if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.populatingBlocks) > 0 {
@ -787,13 +788,18 @@ func TestCancelCompactions(t *testing.T) {
} }
time.Sleep(3 * time.Millisecond) time.Sleep(3 * time.Millisecond)
} }
testutil.Ok(t, db.Close())
}()
db.compact()
} }
// Closing the db in the middle of compaction should take half the time. // Measure the compaction time when closing the db in the middle of compaction.
{ {
db, delete := createTestDb() db, err := Open(tmpdirCopy, log.NewNopLogger(), nil, &Options{BlockRanges: []int64{1, 2000}})
defer delete() testutil.Ok(t, err)
db.DisableCompactions()
db.compactc <- struct{}{} // Trigger a compaction. testutil.Equals(t, 3, len(db.Blocks()), "initial block count mismatch")
testutil.Equals(t, 0.0, prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.ran), "initial compaction counter mismatch")
go func() {
dbClosed := make(chan struct{}) dbClosed := make(chan struct{})
for { for {
if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.populatingBlocks) > 0 { if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.populatingBlocks) > 0 {
@ -809,9 +815,9 @@ func TestCancelCompactions(t *testing.T) {
start := time.Now() start := time.Now()
<-dbClosed <-dbClosed
actT := time.Since(start) actT := time.Since(start)
fmt.Println(timeCompactionUninterrupted) expT := time.Duration(timeCompactionUninterrupted / 2) // Closing the db in the middle of compaction should less than half the time.
fmt.Println(actT)
expT := time.Duration(timeCompactionUninterrupted / 2)
testutil.Assert(t, actT < expT, "closing the db took more than expected. exp: <%v, act: %v", expT, actT) testutil.Assert(t, actT < expT, "closing the db took more than expected. exp: <%v, act: %v", expT, actT)
}()
db.compact()
} }
} }