github.com/xfond/eth-implementation@v1.8.9-0.20180514135602-f6bc65fc6811/ethdb/database.go (about) 1 // Copyright 2014 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package ethdb 18 19 import ( 20 "fmt" 21 "strconv" 22 "strings" 23 "sync" 24 "time" 25 26 "github.com/ethereum/go-ethereum/log" 27 "github.com/ethereum/go-ethereum/metrics" 28 "github.com/syndtr/goleveldb/leveldb" 29 "github.com/syndtr/goleveldb/leveldb/errors" 30 "github.com/syndtr/goleveldb/leveldb/filter" 31 "github.com/syndtr/goleveldb/leveldb/iterator" 32 "github.com/syndtr/goleveldb/leveldb/opt" 33 "github.com/syndtr/goleveldb/leveldb/util" 34 ) 35 36 const ( 37 writeDelayNThreshold = 200 38 writeDelayThreshold = 350 * time.Millisecond 39 writeDelayWarningThrottler = 1 * time.Minute 40 ) 41 42 var OpenFileLimit = 64 43 44 type LDBDatabase struct { 45 fn string // filename for reporting 46 db *leveldb.DB // LevelDB instance 47 48 compTimeMeter metrics.Meter // Meter for measuring the total time spent in database compaction 49 compReadMeter metrics.Meter // Meter for measuring the data read during compaction 50 compWriteMeter metrics.Meter // Meter for measuring the data written during compaction 51 writeDelayNMeter metrics.Meter // Meter for measuring the write delay number due to database compaction 52 writeDelayMeter metrics.Meter // Meter for measuring the write delay duration due to database compaction 53 diskReadMeter metrics.Meter // Meter for measuring the effective amount of data read 54 diskWriteMeter metrics.Meter // Meter for measuring the effective amount of data written 55 56 quitLock sync.Mutex // Mutex protecting the quit channel access 57 quitChan chan chan error // Quit channel to stop the metrics collection before closing the database 58 59 log log.Logger // Contextual logger tracking the database path 60 } 61 62 // NewLDBDatabase returns a LevelDB wrapped object. 63 func NewLDBDatabase(file string, cache int, handles int) (*LDBDatabase, error) { 64 logger := log.New("database", file) 65 66 // Ensure we have some minimal caching and file guarantees 67 if cache < 16 { 68 cache = 16 69 } 70 if handles < 16 { 71 handles = 16 72 } 73 logger.Info("Allocated cache and file handles", "cache", cache, "handles", handles) 74 75 // Open the db and recover any potential corruptions 76 db, err := leveldb.OpenFile(file, &opt.Options{ 77 OpenFilesCacheCapacity: handles, 78 BlockCacheCapacity: cache / 2 * opt.MiB, 79 WriteBuffer: cache / 4 * opt.MiB, // Two of these are used internally 80 Filter: filter.NewBloomFilter(10), 81 }) 82 if _, corrupted := err.(*errors.ErrCorrupted); corrupted { 83 db, err = leveldb.RecoverFile(file, nil) 84 } 85 // (Re)check for errors and abort if opening of the db failed 86 if err != nil { 87 return nil, err 88 } 89 return &LDBDatabase{ 90 fn: file, 91 db: db, 92 log: logger, 93 }, nil 94 } 95 96 // Path returns the path to the database directory. 97 func (db *LDBDatabase) Path() string { 98 return db.fn 99 } 100 101 // Put puts the given key / value to the queue 102 func (db *LDBDatabase) Put(key []byte, value []byte) error { 103 return db.db.Put(key, value, nil) 104 } 105 106 func (db *LDBDatabase) Has(key []byte) (bool, error) { 107 return db.db.Has(key, nil) 108 } 109 110 // Get returns the given key if it's present. 111 func (db *LDBDatabase) Get(key []byte) ([]byte, error) { 112 dat, err := db.db.Get(key, nil) 113 if err != nil { 114 return nil, err 115 } 116 return dat, nil 117 } 118 119 // Delete deletes the key from the queue and database 120 func (db *LDBDatabase) Delete(key []byte) error { 121 return db.db.Delete(key, nil) 122 } 123 124 func (db *LDBDatabase) NewIterator() iterator.Iterator { 125 return db.db.NewIterator(nil, nil) 126 } 127 128 // NewIteratorWithPrefix returns a iterator to iterate over subset of database content with a particular prefix. 129 func (db *LDBDatabase) NewIteratorWithPrefix(prefix []byte) iterator.Iterator { 130 return db.db.NewIterator(util.BytesPrefix(prefix), nil) 131 } 132 133 func (db *LDBDatabase) Close() { 134 // Stop the metrics collection to avoid internal database races 135 db.quitLock.Lock() 136 defer db.quitLock.Unlock() 137 138 if db.quitChan != nil { 139 errc := make(chan error) 140 db.quitChan <- errc 141 if err := <-errc; err != nil { 142 db.log.Error("Metrics collection failed", "err", err) 143 } 144 } 145 err := db.db.Close() 146 if err == nil { 147 db.log.Info("Database closed") 148 } else { 149 db.log.Error("Failed to close database", "err", err) 150 } 151 } 152 153 func (db *LDBDatabase) LDB() *leveldb.DB { 154 return db.db 155 } 156 157 // Meter configures the database metrics collectors and 158 func (db *LDBDatabase) Meter(prefix string) { 159 if metrics.Enabled { 160 // Initialize all the metrics collector at the requested prefix 161 db.compTimeMeter = metrics.NewRegisteredMeter(prefix+"compact/time", nil) 162 db.compReadMeter = metrics.NewRegisteredMeter(prefix+"compact/input", nil) 163 db.compWriteMeter = metrics.NewRegisteredMeter(prefix+"compact/output", nil) 164 db.diskReadMeter = metrics.NewRegisteredMeter(prefix+"disk/read", nil) 165 db.diskWriteMeter = metrics.NewRegisteredMeter(prefix+"disk/write", nil) 166 } 167 // Initialize write delay metrics no matter we are in metric mode or not. 168 db.writeDelayMeter = metrics.NewRegisteredMeter(prefix+"compact/writedelay/duration", nil) 169 db.writeDelayNMeter = metrics.NewRegisteredMeter(prefix+"compact/writedelay/counter", nil) 170 171 // Create a quit channel for the periodic collector and run it 172 db.quitLock.Lock() 173 db.quitChan = make(chan chan error) 174 db.quitLock.Unlock() 175 176 go db.meter(3 * time.Second) 177 } 178 179 // meter periodically retrieves internal leveldb counters and reports them to 180 // the metrics subsystem. 181 // 182 // This is how a stats table look like (currently): 183 // Compactions 184 // Level | Tables | Size(MB) | Time(sec) | Read(MB) | Write(MB) 185 // -------+------------+---------------+---------------+---------------+--------------- 186 // 0 | 0 | 0.00000 | 1.27969 | 0.00000 | 12.31098 187 // 1 | 85 | 109.27913 | 28.09293 | 213.92493 | 214.26294 188 // 2 | 523 | 1000.37159 | 7.26059 | 66.86342 | 66.77884 189 // 3 | 570 | 1113.18458 | 0.00000 | 0.00000 | 0.00000 190 // 191 // This is how the write delay look like (currently): 192 // DelayN:5 Delay:406.604657ms 193 // 194 // This is how the iostats look like (currently): 195 // Read(MB):3895.04860 Write(MB):3654.64712 196 func (db *LDBDatabase) meter(refresh time.Duration) { 197 // Create the counters to store current and previous compaction values 198 compactions := make([][]float64, 2) 199 for i := 0; i < 2; i++ { 200 compactions[i] = make([]float64, 3) 201 } 202 // Create storage for iostats. 203 var iostats [2]float64 204 205 // Create storage and warning log tracer for write delay. 206 var ( 207 delaystats [2]int64 208 lastWriteDelay time.Time 209 lastWriteDelayN time.Time 210 ) 211 212 // Iterate ad infinitum and collect the stats 213 for i := 1; ; i++ { 214 // Retrieve the database stats 215 stats, err := db.db.GetProperty("leveldb.stats") 216 if err != nil { 217 db.log.Error("Failed to read database stats", "err", err) 218 return 219 } 220 // Find the compaction table, skip the header 221 lines := strings.Split(stats, "\n") 222 for len(lines) > 0 && strings.TrimSpace(lines[0]) != "Compactions" { 223 lines = lines[1:] 224 } 225 if len(lines) <= 3 { 226 db.log.Error("Compaction table not found") 227 return 228 } 229 lines = lines[3:] 230 231 // Iterate over all the table rows, and accumulate the entries 232 for j := 0; j < len(compactions[i%2]); j++ { 233 compactions[i%2][j] = 0 234 } 235 for _, line := range lines { 236 parts := strings.Split(line, "|") 237 if len(parts) != 6 { 238 break 239 } 240 for idx, counter := range parts[3:] { 241 value, err := strconv.ParseFloat(strings.TrimSpace(counter), 64) 242 if err != nil { 243 db.log.Error("Compaction entry parsing failed", "err", err) 244 return 245 } 246 compactions[i%2][idx] += value 247 } 248 } 249 // Update all the requested meters 250 if db.compTimeMeter != nil { 251 db.compTimeMeter.Mark(int64((compactions[i%2][0] - compactions[(i-1)%2][0]) * 1000 * 1000 * 1000)) 252 } 253 if db.compReadMeter != nil { 254 db.compReadMeter.Mark(int64((compactions[i%2][1] - compactions[(i-1)%2][1]) * 1024 * 1024)) 255 } 256 if db.compWriteMeter != nil { 257 db.compWriteMeter.Mark(int64((compactions[i%2][2] - compactions[(i-1)%2][2]) * 1024 * 1024)) 258 } 259 260 // Retrieve the write delay statistic 261 writedelay, err := db.db.GetProperty("leveldb.writedelay") 262 if err != nil { 263 db.log.Error("Failed to read database write delay statistic", "err", err) 264 return 265 } 266 var ( 267 delayN int64 268 delayDuration string 269 duration time.Duration 270 ) 271 if n, err := fmt.Sscanf(writedelay, "DelayN:%d Delay:%s", &delayN, &delayDuration); n != 2 || err != nil { 272 db.log.Error("Write delay statistic not found") 273 return 274 } 275 duration, err = time.ParseDuration(delayDuration) 276 if err != nil { 277 db.log.Error("Failed to parse delay duration", "err", err) 278 return 279 } 280 if db.writeDelayNMeter != nil { 281 db.writeDelayNMeter.Mark(delayN - delaystats[0]) 282 // If the write delay number been collected in the last minute exceeds the predefined threshold, 283 // print a warning log here. 284 // If a warning that db performance is laggy has been displayed, 285 // any subsequent warnings will be withhold for 1 minute to don't overwhelm the user. 286 if int(db.writeDelayNMeter.Rate1()) > writeDelayNThreshold && 287 time.Now().After(lastWriteDelayN.Add(writeDelayWarningThrottler)) { 288 db.log.Warn("Write delay number exceeds the threshold (200 per second) in the last minute") 289 lastWriteDelayN = time.Now() 290 } 291 } 292 if db.writeDelayMeter != nil { 293 db.writeDelayMeter.Mark(duration.Nanoseconds() - delaystats[1]) 294 // If the write delay duration been collected in the last minute exceeds the predefined threshold, 295 // print a warning log here. 296 // If a warning that db performance is laggy has been displayed, 297 // any subsequent warnings will be withhold for 1 minute to don't overwhelm the user. 298 if int64(db.writeDelayMeter.Rate1()) > writeDelayThreshold.Nanoseconds() && 299 time.Now().After(lastWriteDelay.Add(writeDelayWarningThrottler)) { 300 db.log.Warn("Write delay duration exceeds the threshold (35% of the time) in the last minute") 301 lastWriteDelay = time.Now() 302 } 303 } 304 delaystats[0], delaystats[1] = delayN, duration.Nanoseconds() 305 306 // Retrieve the database iostats. 307 ioStats, err := db.db.GetProperty("leveldb.iostats") 308 if err != nil { 309 db.log.Error("Failed to read database iostats", "err", err) 310 return 311 } 312 parts := strings.Split(ioStats, " ") 313 if len(parts) < 2 { 314 db.log.Error("Bad syntax of ioStats", "ioStats", ioStats) 315 return 316 } 317 r := strings.Split(parts[0], ":") 318 if len(r) < 2 { 319 db.log.Error("Bad syntax of read entry", "entry", parts[0]) 320 return 321 } 322 read, err := strconv.ParseFloat(r[1], 64) 323 if err != nil { 324 db.log.Error("Read entry parsing failed", "err", err) 325 return 326 } 327 w := strings.Split(parts[1], ":") 328 if len(w) < 2 { 329 db.log.Error("Bad syntax of write entry", "entry", parts[1]) 330 return 331 } 332 write, err := strconv.ParseFloat(w[1], 64) 333 if err != nil { 334 db.log.Error("Write entry parsing failed", "err", err) 335 return 336 } 337 if db.diskReadMeter != nil { 338 db.diskReadMeter.Mark(int64((read - iostats[0]) * 1024 * 1024)) 339 } 340 if db.diskWriteMeter != nil { 341 db.diskWriteMeter.Mark(int64((write - iostats[1]) * 1024 * 1024)) 342 } 343 iostats[0] = read 344 iostats[1] = write 345 346 // Sleep a bit, then repeat the stats collection 347 select { 348 case errc := <-db.quitChan: 349 // Quit requesting, stop hammering the database 350 errc <- nil 351 return 352 353 case <-time.After(refresh): 354 // Timeout, gather a new set of stats 355 } 356 } 357 } 358 359 func (db *LDBDatabase) NewBatch() Batch { 360 return &ldbBatch{db: db.db, b: new(leveldb.Batch)} 361 } 362 363 type ldbBatch struct { 364 db *leveldb.DB 365 b *leveldb.Batch 366 size int 367 } 368 369 func (b *ldbBatch) Put(key, value []byte) error { 370 b.b.Put(key, value) 371 b.size += len(value) 372 return nil 373 } 374 375 func (b *ldbBatch) Write() error { 376 return b.db.Write(b.b, nil) 377 } 378 379 func (b *ldbBatch) ValueSize() int { 380 return b.size 381 } 382 383 func (b *ldbBatch) Reset() { 384 b.b.Reset() 385 b.size = 0 386 } 387 388 type table struct { 389 db Database 390 prefix string 391 } 392 393 // NewTable returns a Database object that prefixes all keys with a given 394 // string. 395 func NewTable(db Database, prefix string) Database { 396 return &table{ 397 db: db, 398 prefix: prefix, 399 } 400 } 401 402 func (dt *table) Put(key []byte, value []byte) error { 403 return dt.db.Put(append([]byte(dt.prefix), key...), value) 404 } 405 406 func (dt *table) Has(key []byte) (bool, error) { 407 return dt.db.Has(append([]byte(dt.prefix), key...)) 408 } 409 410 func (dt *table) Get(key []byte) ([]byte, error) { 411 return dt.db.Get(append([]byte(dt.prefix), key...)) 412 } 413 414 func (dt *table) Delete(key []byte) error { 415 return dt.db.Delete(append([]byte(dt.prefix), key...)) 416 } 417 418 func (dt *table) Close() { 419 // Do nothing; don't close the underlying DB. 420 } 421 422 type tableBatch struct { 423 batch Batch 424 prefix string 425 } 426 427 // NewTableBatch returns a Batch object which prefixes all keys with a given string. 428 func NewTableBatch(db Database, prefix string) Batch { 429 return &tableBatch{db.NewBatch(), prefix} 430 } 431 432 func (dt *table) NewBatch() Batch { 433 return &tableBatch{dt.db.NewBatch(), dt.prefix} 434 } 435 436 func (tb *tableBatch) Put(key, value []byte) error { 437 return tb.batch.Put(append([]byte(tb.prefix), key...), value) 438 } 439 440 func (tb *tableBatch) Write() error { 441 return tb.batch.Write() 442 } 443 444 func (tb *tableBatch) ValueSize() int { 445 return tb.batch.ValueSize() 446 } 447 448 func (tb *tableBatch) Reset() { 449 tb.batch.Reset() 450 }