tmps prety display,overlapping blocks

Signed-off-by: Krasi Georgiev <[email protected]>

Author: Krasi Georgiev

cmd/tsdb/main.go

@@ -70,7 +70,6 @@ func main() {
 		printBlocks(db.Blocks(), listCmdHumanReadable)
 
 	case scanCmd.FullCommand():
-		fmt.Println("Scanning for temporary files...")
 		var tmpFiles []string
 		filepath.Walk(*scanPath, func(path string, f os.FileInfo, _ error) error {
 			if !f.IsDir() {
@@ -86,17 +85,35 @@ These are usually caused by a crash or incomplete compaction and
 are safe to delete as long as you are sure that no other application is currently using this database.`)
 
 			promptDelete(tmpFiles, scanCmdHumanReadable)
-
 		}
 
 		scanner, err := tsdb.NewDBScanner(*scanPath)
 		if err != nil {
 			exitWithError(err)
 		}
 
-		for err, useless := range scanner.Scan() {
-			fmt.Printf("Deleting these will loose all data in the listed time ranges.%v", err)
-			promptDelete(useless, scanCmdHumanReadable)
+		for err, unreadable := range scanner.Scan() {
+			switch err.(type) {
+			case tsdb.ErrOverlap:
+				var biggestIndex int
+				biggest := &tsdb.Block{}
+				for i, b := range unreadable {
+					if b.Meta().Stats.NumSamples > biggest.Meta().Stats.NumSamples {
+						biggest = b
+						biggestIndex = i
+					}
+				}
+				// Don't delete the bigest block in the overlaps.
+				unreadable = append(unreadable[:biggestIndex], unreadable[biggestIndex+1:]...)
+
+				fmt.Printf("\n%v \nDeleting these will loose all data in the listed time ranges.\n\n", err)
+				fmt.Printf("\nBlock %v contains most samples  is ommited from the list and it won't be deleted! \n\n", biggest)
+
+			default:
+				fmt.Printf("\nUnreadable blocks : %v \nDeleting these will loose all data in the listed time ranges.\n\n", err)
+
+			}
+			promptDelete(unreadable, scanCmdHumanReadable)
 		}
 	}
 	flag.CommandLine.Set("log.level", "debug")
@@ -116,7 +133,7 @@ func promptDelete(i interface{}, humanReadable *bool) {
 		printTmps(paths, humanReadable)
 	}
 
-	fmt.Printf("Do you want to delete these (y/N)? ")
+	fmt.Printf("DELETE (y/N)? ")
 	var s string
 	_, err := fmt.Scanln(&s)
 	if err != nil {
@@ -131,8 +148,8 @@ func promptDelete(i interface{}, humanReadable *bool) {
 			if err := os.Remove(path); err != nil {
 				fmt.Printf("error deleting: %v, %v", path, err)
 			}
-			fmt.Printf("%v \n", path)
 		}
+		return
 	}
 	if s == "n" || s == "no" {
 		return
@@ -420,26 +437,39 @@ func exitWithError(err error) {
 }
 
 func printTmps(tmps []string, humanReadable *bool) {
+	tw := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	defer tw.Flush()
 
-	fmt.Println(tmps)
+	fmt.Fprintln(tw, "PATH\tSIZE\tDATE\t")
+	for _, path := range tmps {
+		f, e := os.Stat(path)
+		if e != nil {
+			exitWithError(e)
+		}
+		fmt.Fprintf(tw,
+			"%v\t%v\t%v\n",
+			path, f.Size(), f.ModTime().Format("2006-Jan-2 15:04:05 -07:00 MST"),
+		)
+	}
 }
 
 func printBlocks(blocks []*tsdb.Block, humanReadable *bool) {
 	tw := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
 	defer tw.Flush()
 
-	fmt.Fprintln(tw, "BLOCK ULID\tMIN TIME\tMAX TIME\tNUM SAMPLES\tNUM CHUNKS\tNUM SERIES")
+	fmt.Fprintln(tw, "BLOCK ULID\tMIN TIME\tMAX TIME\tNUM SAMPLES\tNUM CHUNKS\tNUM SERIES\tPATH")
 	for _, b := range blocks {
 		meta := b.Meta()
 
 		fmt.Fprintf(tw,
-			"%v\t%v\t%v\t%v\t%v\t%v\n",
+			"%v\t%v\t%v\t%v\t%v\t%v\t%v\n",
 			meta.ULID,
 			getFormatedTime(meta.MinTime, humanReadable),
 			getFormatedTime(meta.MaxTime, humanReadable),
 			meta.Stats.NumSamples,
 			meta.Stats.NumChunks,
 			meta.Stats.NumSeries,
+			b.Dir(),
 		)
 	}
 }

scan.go

@@ -3,12 +3,19 @@ package tsdb
 import (
 	"fmt"
 	"path/filepath"
+	"time"
 
 	"github.com/pkg/errors"
 	"github.com/prometheus/tsdb/chunks"
 	"github.com/prometheus/tsdb/index"
 )
 
+type ErrOverlap string
+
+func (e ErrOverlap) Error() string {
+	return string(e)
+}
+
 type DBScanner struct {
 	db   *DB
 	dirs []string
@@ -32,63 +39,64 @@ func NewDBScanner(dir string) (*DBScanner, error) {
 	return dbScanner, nil
 }
 
-// Scan checks the integrity of the tsdb and returns a slice of blocks that return an error while processing.
+// Scan checks the integrity of the tsdb and returns a slice of unreadable blocks.
 // The blocks are grouped in a map by the error.
 func (db *DBScanner) Scan() map[error][]*Block {
 
-	uselessBlocks := make(map[error][]*Block)
+	unreadableBlocks := make(map[error][]*Block)
 	var goodBlocks []*Block
 
 	for _, dir := range db.dirs {
 		var err error
 		block := &Block{
 			dir: dir,
 		}
+
+	loop:
 		for {
-			meta, err := readMetaFile(dir)
+			var meta = &BlockMeta{}
+			meta, err = readMetaFile(dir)
 			if err != nil {
-				err = errors.Wrap(err, "reading block meta")
-				break
+				err = errors.Wrap(err, "meta error")
+				break loop
 			}
 			block.meta = *meta
 
 			if block.chunkr, err = chunks.NewDirReader(chunkDir(dir), nil); err != nil {
-				err = errors.Wrap(err, "reading block chunk")
-				break
+				err = errors.Wrap(err, "chunk error")
+				break loop
 			}
 
 			if block.indexr, err = index.NewFileReader(filepath.Join(dir, "index")); err != nil {
-				err = errors.Wrap(err, "reading block index")
-				break
+				err = errors.Wrap(err, "index error")
+				break loop
 			}
 
 			if block.tombstones, err = readTombstones(dir); err != nil {
-				err = errors.Wrap(err, "reading block tumbstone")
-				break
+				err = errors.Wrap(err, "tumbstone error")
+				break loop
 			}
-			break
+			break loop
 		}
 
 		if err != nil {
-			uselessBlocks[err] = append(uselessBlocks[err], block)
+			unreadableBlocks[err] = append(unreadableBlocks[err], block)
 		} else {
 			goodBlocks = append(goodBlocks, block)
 		}
-
 	}
 
 	// Scan for overlaping blocks.
-	for time, overlappingMetas := range validateBlockSequence(goodBlocks) {
-		err := fmt.Errorf("overlapping blocks range: %v , %v", time.Min, time.Min)
+	for t, overlappingMetas := range validateBlockSequence(goodBlocks) {
+		err := ErrOverlap(fmt.Sprintf("overlapping blocks : %v-%v ", time.Unix(t.Min/1000, 0).Format("06/01/02 15:04"), time.Unix(t.Max/1000, 0).Format("15:04 06/01/02")))
 		for _, m := range overlappingMetas {
 			for _, b := range goodBlocks {
-				if m.ULID == b.Meta().ULID {
-					uselessBlocks[err] = append(uselessBlocks[err], b)
+				if m.ULID == b.Meta().ULID && m.Stats == b.Meta().Stats {
+					unreadableBlocks[err] = append(unreadableBlocks[err], b)
 					break
 				}
 			}
 		}
-
 	}
-	return uselessBlocks
+	return unreadableBlocks
 }