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