-
Notifications
You must be signed in to change notification settings - Fork 721
/
types.go
338 lines (296 loc) · 12.5 KB
/
types.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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
// Copyright 2023 TiKV Project Authors.
//
// 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,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package http
import (
"encoding/json"
"time"
)
// KeyRange defines a range of keys.
type KeyRange struct {
StartKey []byte `json:"start_key"`
EndKey []byte `json:"end_key"`
}
// NOTICE: the structures below are copied from the PD API definitions.
// Please make sure the consistency if any change happens to the PD API.
// RegionInfo stores the information of one region.
type RegionInfo struct {
ID int64 `json:"id"`
StartKey string `json:"start_key"`
EndKey string `json:"end_key"`
Epoch RegionEpoch `json:"epoch"`
Peers []RegionPeer `json:"peers"`
Leader RegionPeer `json:"leader"`
DownPeers []RegionPeerStat `json:"down_peers"`
PendingPeers []RegionPeer `json:"pending_peers"`
WrittenBytes uint64 `json:"written_bytes"`
ReadBytes uint64 `json:"read_bytes"`
ApproximateSize int64 `json:"approximate_size"`
ApproximateKeys int64 `json:"approximate_keys"`
ReplicationStatus *ReplicationStatus `json:"replication_status,omitempty"`
}
// GetStartKey gets the start key of the region.
func (r *RegionInfo) GetStartKey() string { return r.StartKey }
// GetEndKey gets the end key of the region.
func (r *RegionInfo) GetEndKey() string { return r.EndKey }
// RegionEpoch stores the information about its epoch.
type RegionEpoch struct {
ConfVer int64 `json:"conf_ver"`
Version int64 `json:"version"`
}
// RegionPeer stores information of one peer.
type RegionPeer struct {
ID int64 `json:"id"`
StoreID int64 `json:"store_id"`
IsLearner bool `json:"is_learner"`
}
// RegionPeerStat stores one field `DownSec` which indicates how long it's down than `RegionPeer`.
type RegionPeerStat struct {
Peer RegionPeer `json:"peer"`
DownSec int64 `json:"down_seconds"`
}
// ReplicationStatus represents the replication mode status of the region.
type ReplicationStatus struct {
State string `json:"state"`
StateID int64 `json:"state_id"`
}
// RegionsInfo stores the information of regions.
type RegionsInfo struct {
Count int64 `json:"count"`
Regions []RegionInfo `json:"regions"`
}
// Merge merges two RegionsInfo together and returns a new one.
func (ri *RegionsInfo) Merge(other *RegionsInfo) *RegionsInfo {
newRegionsInfo := &RegionsInfo{
Regions: make([]RegionInfo, 0, ri.Count+other.Count),
}
m := make(map[int64]RegionInfo, ri.Count+other.Count)
for _, region := range ri.Regions {
m[region.ID] = region
}
for _, region := range other.Regions {
m[region.ID] = region
}
for _, region := range m {
newRegionsInfo.Regions = append(newRegionsInfo.Regions, region)
}
newRegionsInfo.Count = int64(len(newRegionsInfo.Regions))
return newRegionsInfo
}
// StoreHotPeersInfos is used to get human-readable description for hot regions.
type StoreHotPeersInfos struct {
AsPeer StoreHotPeersStat `json:"as_peer"`
AsLeader StoreHotPeersStat `json:"as_leader"`
}
// StoreHotPeersStat is used to record the hot region statistics group by store.
type StoreHotPeersStat map[uint64]*HotPeersStat
// HotPeersStat records all hot regions statistics
type HotPeersStat struct {
StoreByteRate float64 `json:"store_bytes"`
StoreKeyRate float64 `json:"store_keys"`
StoreQueryRate float64 `json:"store_query"`
TotalBytesRate float64 `json:"total_flow_bytes"`
TotalKeysRate float64 `json:"total_flow_keys"`
TotalQueryRate float64 `json:"total_flow_query"`
Count int `json:"regions_count"`
Stats []HotPeerStatShow `json:"statistics"`
}
// HotPeerStatShow records the hot region statistics for output
type HotPeerStatShow struct {
StoreID uint64 `json:"store_id"`
Stores []uint64 `json:"stores"`
IsLeader bool `json:"is_leader"`
IsLearner bool `json:"is_learner"`
RegionID uint64 `json:"region_id"`
HotDegree int `json:"hot_degree"`
ByteRate float64 `json:"flow_bytes"`
KeyRate float64 `json:"flow_keys"`
QueryRate float64 `json:"flow_query"`
AntiCount int `json:"anti_count"`
LastUpdateTime time.Time `json:"last_update_time,omitempty"`
}
// StoresInfo represents the information of all TiKV/TiFlash stores.
type StoresInfo struct {
Count int `json:"count"`
Stores []StoreInfo `json:"stores"`
}
// StoreInfo represents the information of one TiKV/TiFlash store.
type StoreInfo struct {
Store MetaStore `json:"store"`
Status StoreStatus `json:"status"`
}
// MetaStore represents the meta information of one store.
type MetaStore struct {
ID int64 `json:"id"`
Address string `json:"address"`
State int64 `json:"state"`
StateName string `json:"state_name"`
Version string `json:"version"`
Labels []StoreLabel `json:"labels"`
StatusAddress string `json:"status_address"`
GitHash string `json:"git_hash"`
StartTimestamp int64 `json:"start_timestamp"`
}
// StoreLabel stores the information of one store label.
type StoreLabel struct {
Key string `json:"key"`
Value string `json:"value"`
}
// StoreStatus stores the detail information of one store.
type StoreStatus struct {
Capacity string `json:"capacity"`
Available string `json:"available"`
LeaderCount int64 `json:"leader_count"`
LeaderWeight float64 `json:"leader_weight"`
LeaderScore float64 `json:"leader_score"`
LeaderSize int64 `json:"leader_size"`
RegionCount int64 `json:"region_count"`
RegionWeight float64 `json:"region_weight"`
RegionScore float64 `json:"region_score"`
RegionSize int64 `json:"region_size"`
StartTS time.Time `json:"start_ts"`
LastHeartbeatTS time.Time `json:"last_heartbeat_ts"`
Uptime string `json:"uptime"`
}
// RegionStats stores the statistics of regions.
type RegionStats struct {
Count int `json:"count"`
EmptyCount int `json:"empty_count"`
StorageSize int64 `json:"storage_size"`
StorageKeys int64 `json:"storage_keys"`
StoreLeaderCount map[uint64]int `json:"store_leader_count"`
StorePeerCount map[uint64]int `json:"store_peer_count"`
}
// PeerRoleType is the expected peer type of the placement rule.
type PeerRoleType string
const (
// Voter can either match a leader peer or follower peer
Voter PeerRoleType = "voter"
// Leader matches a leader.
Leader PeerRoleType = "leader"
// Follower matches a follower.
Follower PeerRoleType = "follower"
// Learner matches a learner.
Learner PeerRoleType = "learner"
)
// LabelConstraint is used to filter store when trying to place peer of a region.
type LabelConstraint struct {
Key string `json:"key,omitempty"`
Op LabelConstraintOp `json:"op,omitempty"`
Values []string `json:"values,omitempty"`
}
// LabelConstraintOp defines how a LabelConstraint matches a store. It can be one of
// 'in', 'notIn', 'exists', or 'notExists'.
type LabelConstraintOp string
const (
// In restricts the store label value should in the value list.
// If label does not exist, `in` is always false.
In LabelConstraintOp = "in"
// NotIn restricts the store label value should not in the value list.
// If label does not exist, `notIn` is always true.
NotIn LabelConstraintOp = "notIn"
// Exists restricts the store should have the label.
Exists LabelConstraintOp = "exists"
// NotExists restricts the store should not have the label.
NotExists LabelConstraintOp = "notExists"
)
// Rule is the placement rule that can be checked against a region. When
// applying rules (apply means schedule regions to match selected rules), the
// apply order is defined by the tuple [GroupIndex, GroupID, Index, ID].
type Rule struct {
GroupID string `json:"group_id"` // mark the source that add the rule
ID string `json:"id"` // unique ID within a group
Index int `json:"index,omitempty"` // rule apply order in a group, rule with less ID is applied first when indexes are equal
Override bool `json:"override,omitempty"` // when it is true, all rules with less indexes are disabled
StartKey []byte `json:"-"` // range start key
StartKeyHex string `json:"start_key"` // hex format start key, for marshal/unmarshal
EndKey []byte `json:"-"` // range end key
EndKeyHex string `json:"end_key"` // hex format end key, for marshal/unmarshal
Role PeerRoleType `json:"role"` // expected role of the peers
IsWitness bool `json:"is_witness"` // when it is true, it means the role is also a witness
Count int `json:"count"` // expected count of the peers
LabelConstraints []LabelConstraint `json:"label_constraints,omitempty"` // used to select stores to place peers
LocationLabels []string `json:"location_labels,omitempty"` // used to make peers isolated physically
IsolationLevel string `json:"isolation_level,omitempty"` // used to isolate replicas explicitly and forcibly
Version uint64 `json:"version,omitempty"` // only set at runtime, add 1 each time rules updated, begin from 0.
CreateTimestamp uint64 `json:"create_timestamp,omitempty"` // only set at runtime, recorded rule create timestamp
}
// String returns the string representation of this rule.
func (r *Rule) String() string {
b, _ := json.Marshal(r)
return string(b)
}
// Clone returns a copy of Rule.
func (r *Rule) Clone() *Rule {
var clone Rule
json.Unmarshal([]byte(r.String()), &clone)
clone.StartKey = append(r.StartKey[:0:0], r.StartKey...)
clone.EndKey = append(r.EndKey[:0:0], r.EndKey...)
return &clone
}
// RuleOpType indicates the operation type
type RuleOpType string
const (
// RuleOpAdd a placement rule, only need to specify the field *Rule
RuleOpAdd RuleOpType = "add"
// RuleOpDel a placement rule, only need to specify the field `GroupID`, `ID`, `MatchID`
RuleOpDel RuleOpType = "del"
)
// RuleOp is for batching placement rule actions.
// The action type is distinguished by the field `Action`.
type RuleOp struct {
*Rule // information of the placement rule to add/delete the operation type
Action RuleOpType `json:"action"`
DeleteByIDPrefix bool `json:"delete_by_id_prefix"` // if action == delete, delete by the prefix of id
}
func (r RuleOp) String() string {
b, _ := json.Marshal(r)
return string(b)
}
// RuleGroup defines properties of a rule group.
type RuleGroup struct {
ID string `json:"id,omitempty"`
Index int `json:"index,omitempty"`
Override bool `json:"override,omitempty"`
}
func (g *RuleGroup) String() string {
b, _ := json.Marshal(g)
return string(b)
}
// GroupBundle represents a rule group and all rules belong to the group.
type GroupBundle struct {
ID string `json:"group_id"`
Index int `json:"group_index"`
Override bool `json:"group_override"`
Rules []*Rule `json:"rules"`
}
// RegionLabel is the label of a region.
type RegionLabel struct {
Key string `json:"key"`
Value string `json:"value"`
TTL string `json:"ttl,omitempty"`
StartAt string `json:"start_at,omitempty"`
}
// LabelRule is the rule to assign labels to a region.
type LabelRule struct {
ID string `json:"id"`
Index int `json:"index"`
Labels []RegionLabel `json:"labels"`
RuleType string `json:"rule_type"`
Data interface{} `json:"data"`
}
// LabelRulePatch is the patch to update the label rules.
type LabelRulePatch struct {
SetRules []*LabelRule `json:"sets"`
DeleteRules []string `json:"deletes"`
}