/
util.go
83 lines (64 loc) · 1.65 KB
/
util.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
// Copyright 2019 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
package storage
import (
"encoding/binary"
"sync/atomic"
"github.com/dustin/go-humanize"
"github.com/pingcap/errors"
)
var tsKeyPrefix = []byte("ts:")
func decodeTSKey(key []byte) int64 {
// check bound
_ = key[len(tsKeyPrefix)+8-1]
return int64(binary.BigEndian.Uint64(key[len(tsKeyPrefix):]))
}
func encodeTSKey(ts int64) []byte {
buf := make([]byte, 8+len(tsKeyPrefix))
copy(buf, tsKeyPrefix)
b := buf[len(tsKeyPrefix):]
binary.BigEndian.PutUint64(b, uint64(ts))
return buf
}
// HumanizeBytes is used for humanize configure
type HumanizeBytes uint64
// Uint64 return bytes
func (b HumanizeBytes) Uint64() uint64 {
return uint64(b)
}
// UnmarshalText implements UnmarshalText
func (b *HumanizeBytes) UnmarshalText(text []byte) error {
var err error
if len(text) == 0 {
*b = 0
return nil
}
n, err := humanize.ParseBytes(string(text))
if err != nil {
return errors.Annotatef(err, "text: %s", string(text))
}
*b = HumanizeBytes(n)
return nil
}
// test helper
type memOracle struct {
ts int64
}
func newMemOracle() *memOracle {
return &memOracle{
ts: 0,
}
}
func (o *memOracle) getTS() int64 {
return atomic.AddInt64(&o.ts, 1)
}