ethdb: remove Flush

eth/backend.go

@@ -213,9 +213,6 @@ type Ethereum struct {
 	chainDb ethdb.Database // Block chain database
 	dappDb  ethdb.Database // Dapp database
 
-	// Closed when databases are flushed and closed
-	databasesClosed chan bool
-
 	//*** SERVICES ***
 	// State manager for processing new blocks and managing the over all states
 	blockProcessor  *core.BlockProcessor
@@ -337,7 +334,6 @@ func New(config *Config) (*Ethereum, error) {
 
 	eth := &Ethereum{
 		shutdownChan:            make(chan bool),
-		databasesClosed:         make(chan bool),
 		chainDb:                 chainDb,
 		dappDb:                  dappDb,
 		eventMux:                &event.TypeMux{},
@@ -549,8 +545,6 @@ func (s *Ethereum) Start() error {
 	if err != nil {
 		return err
 	}
-	// periodically flush databases
-	go s.syncDatabases()
 
 	if s.AutoDAG {
 		s.StartAutoDAG()
@@ -566,32 +560,6 @@ func (s *Ethereum) Start() error {
 	return nil
 }
 
-// sync databases every minute. If flushing fails we exit immediatly. The system
-// may not continue under any circumstances.
-func (s *Ethereum) syncDatabases() {
-	ticker := time.NewTicker(1 * time.Minute)
-done:
-	for {
-		select {
-		case <-ticker.C:
-			// don't change the order of database flushes
-			if err := s.dappDb.Flush(); err != nil {
-				glog.Fatalf("fatal error: flush dappDb: %v (Restart your node. We are aware of this issue)\n", err)
-			}
-			if err := s.chainDb.Flush(); err != nil {
-				glog.Fatalf("fatal error: flush chainDb: %v (Restart your node. We are aware of this issue)\n", err)
-			}
-		case <-s.shutdownChan:
-			break done
-		}
-	}
-
-	s.chainDb.Close()
-	s.dappDb.Close()
-
-	close(s.databasesClosed)
-}
-
 func (s *Ethereum) StartForTest() {
 	jsonlogger.LogJson(&logger.LogStarting{
 		ClientString:    s.net.Name,
@@ -622,12 +590,13 @@ func (s *Ethereum) Stop() {
 	}
 	s.StopAutoDAG()
 
+	s.chainDb.Close()
+	s.dappDb.Close()
 	close(s.shutdownChan)
 }
 
 // This function will wait for a shutdown and resumes main thread execution
 func (s *Ethereum) WaitForShutdown() {
-	<-s.databasesClosed
 	<-s.shutdownChan
 }
 

ethdb/database.go

@@ -61,9 +61,7 @@ type LDBDatabase struct {
 	quitChan chan chan error // Quit channel to stop the metrics collection before closing the database
 }
 
-// NewLDBDatabase returns a LevelDB wrapped object. LDBDatabase does not persist data by
+// NewLDBDatabase returns a LevelDB wrapped object.
-// it self but requires a background poller which syncs every X. `Flush` should be called
-// when data needs to be stored and written to disk.
 func NewLDBDatabase(file string, cache int) (*LDBDatabase, error) {
 	// Calculate the cache allowance for this particular database
 	cache = int(float64(cache) * cacheRatio[filepath.Base(file)])
@@ -142,11 +140,6 @@ func (self *LDBDatabase) NewIterator() iterator.Iterator {
 	return self.db.NewIterator(nil, nil)
 }
 
-// Flush flushes out the queue to leveldb
-func (self *LDBDatabase) Flush() error {
-	return nil
-}
-
 func (self *LDBDatabase) Close() {
 	// Stop the metrics collection to avoid internal database races
 	self.quitLock.Lock()
@@ -159,12 +152,14 @@ func (self *LDBDatabase) Close() {
 			glog.V(logger.Error).Infof("metrics failure in '%s': %v\n", self.fn, err)
 		}
 	}
-	// Flush and close the database
+	err := self.db.Close()
-	if err := self.Flush(); err != nil {
+	if glog.V(logger.Error) {
-		glog.V(logger.Error).Infof("flushing '%s' failed: %v\n", self.fn, err)
+		if err == nil {
+			glog.Infoln("closed db:", self.fn)
+		} else {
+			glog.Errorf("error closing db %s: %v", self.fn, err)
+		}
 	}
-	self.db.Close()
-	glog.V(logger.Error).Infoln("flushed and closed db:", self.fn)
 }
 
 func (self *LDBDatabase) LDB() *leveldb.DB {

ethdb/interface.go

@@ -21,7 +21,6 @@ type Database interface {
 	Get(key []byte) ([]byte, error)
 	Delete(key []byte) error
 	Close()
-	Flush() error
 	NewBatch() Batch
 }
 

ethdb/memory_database.go

@@ -91,10 +91,6 @@ func (db *MemDatabase) LastKnownTD() []byte {
 	return data
 }
 
-func (db *MemDatabase) Flush() error {
-	return nil
-}
-
 func (db *MemDatabase) NewBatch() Batch {
 	return &memBatch{db: db}
 }