swarm/storage: release chunk storage after stop swarm (#3651)

closes #3650
This commit is contained in:
Maksim 2017-02-09 00:01:12 +07:00 committed by Felix Lange
parent fa99986143
commit 6dd27e7cff
8 changed files with 36 additions and 9 deletions

View File

@ -408,7 +408,7 @@ func (s *DbStore) getEntryCnt() uint64 {
return s.entryCnt return s.entryCnt
} }
func (s *DbStore) close() { func (s *DbStore) Close() {
s.db.Close() s.db.Close()
} }

View File

@ -38,7 +38,7 @@ func initDbStore(t *testing.T) *DbStore {
func testDbStore(l int64, branches int64, t *testing.T) { func testDbStore(l int64, branches int64, t *testing.T) {
m := initDbStore(t) m := initDbStore(t)
defer m.close() defer m.Close()
testStore(m, l, branches, t) testStore(m, l, branches, t)
} }
@ -64,7 +64,7 @@ func TestDbStore2_100_(t *testing.T) {
func TestDbStoreNotFound(t *testing.T) { func TestDbStoreNotFound(t *testing.T) {
m := initDbStore(t) m := initDbStore(t)
defer m.close() defer m.Close()
_, err := m.Get(ZeroKey) _, err := m.Get(ZeroKey)
if err != notFound { if err != notFound {
t.Errorf("Expected notFound, got %v", err) t.Errorf("Expected notFound, got %v", err)
@ -73,7 +73,7 @@ func TestDbStoreNotFound(t *testing.T) {
func TestDbStoreSyncIterator(t *testing.T) { func TestDbStoreSyncIterator(t *testing.T) {
m := initDbStore(t) m := initDbStore(t)
defer m.close() defer m.Close()
keys := []Key{ keys := []Key{
Key(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000")), Key(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000")),
Key(common.Hex2Bytes("4000000000000000000000000000000000000000000000000000000000000000")), Key(common.Hex2Bytes("4000000000000000000000000000000000000000000000000000000000000000")),

View File

@ -237,3 +237,8 @@ func (self *dpaChunkStore) Put(entry *Chunk) {
self.n++ self.n++
self.netStore.Put(chunk) self.netStore.Put(chunk)
} }
// Close chunk store
func (self *dpaChunkStore) Close() {
return
}

View File

@ -72,3 +72,8 @@ func (self *LocalStore) Get(key Key) (chunk *Chunk, err error) {
self.memStore.Put(chunk) self.memStore.Put(chunk)
return return
} }
// Close local store
func (self *LocalStore) Close() {
return
}

View File

@ -314,3 +314,8 @@ func (s *MemStore) removeOldest() {
} }
} }
} }
// Close memstore
func (s *MemStore) Close() {
return
}

View File

@ -132,3 +132,8 @@ func (self *NetStore) Get(key Key) (*Chunk, error) {
go self.cloud.Retrieve(chunk) go self.cloud.Retrieve(chunk)
return chunk, nil return chunk, nil
} }
// Close netstore
func (self *NetStore) Close() {
return
}

View File

@ -167,6 +167,7 @@ The ChunkStore interface is implemented by :
type ChunkStore interface { type ChunkStore interface {
Put(*Chunk) // effectively there is no error even if there is an error Put(*Chunk) // effectively there is no error even if there is an error
Get(Key) (*Chunk, error) Get(Key) (*Chunk, error)
Close()
} }
/* /*

View File

@ -54,6 +54,7 @@ type Swarm struct {
privateKey *ecdsa.PrivateKey privateKey *ecdsa.PrivateKey
corsString string corsString string
swapEnabled bool swapEnabled bool
lstore *storage.LocalStore // local store, needs to store for releasing resources after node stopped
} }
type SwarmAPI struct { type SwarmAPI struct {
@ -90,7 +91,7 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, config *api.
glog.V(logger.Debug).Infof("Setting up Swarm service components") glog.V(logger.Debug).Infof("Setting up Swarm service components")
hash := storage.MakeHashFunc(config.ChunkerParams.Hash) hash := storage.MakeHashFunc(config.ChunkerParams.Hash)
lstore, err := storage.NewLocalStore(hash, config.StoreParams) self.lstore, err = storage.NewLocalStore(hash, config.StoreParams)
if err != nil { if err != nil {
return return
} }
@ -98,7 +99,7 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, config *api.
// setup local store // setup local store
glog.V(logger.Debug).Infof("Set up local storage") glog.V(logger.Debug).Infof("Set up local storage")
self.dbAccess = network.NewDbAccess(lstore) self.dbAccess = network.NewDbAccess(self.lstore)
glog.V(logger.Debug).Infof("Set up local db access (iterator/counter)") glog.V(logger.Debug).Infof("Set up local db access (iterator/counter)")
// set up the kademlia hive // set up the kademlia hive
@ -115,15 +116,15 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, config *api.
glog.V(logger.Debug).Infof("-> set swarm forwarder as cloud storage backend") glog.V(logger.Debug).Infof("-> set swarm forwarder as cloud storage backend")
// setup cloud storage internal access layer // setup cloud storage internal access layer
self.storage = storage.NewNetStore(hash, lstore, cloud, config.StoreParams) self.storage = storage.NewNetStore(hash, self.lstore, cloud, config.StoreParams)
glog.V(logger.Debug).Infof("-> swarm net store shared access layer to Swarm Chunk Store") glog.V(logger.Debug).Infof("-> swarm net store shared access layer to Swarm Chunk Store")
// set up Depo (storage handler = cloud storage access layer for incoming remote requests) // set up Depo (storage handler = cloud storage access layer for incoming remote requests)
self.depo = network.NewDepo(hash, lstore, self.storage) self.depo = network.NewDepo(hash, self.lstore, self.storage)
glog.V(logger.Debug).Infof("-> REmote Access to CHunks") glog.V(logger.Debug).Infof("-> REmote Access to CHunks")
// set up DPA, the cloud storage local access layer // set up DPA, the cloud storage local access layer
dpaChunkStore := storage.NewDpaChunkStore(lstore, self.storage) dpaChunkStore := storage.NewDpaChunkStore(self.lstore, self.storage)
glog.V(logger.Debug).Infof("-> Local Access to Swarm") glog.V(logger.Debug).Infof("-> Local Access to Swarm")
// Swarm Hash Merklised Chunking for Arbitrary-length Document/File storage // Swarm Hash Merklised Chunking for Arbitrary-length Document/File storage
self.dpa = storage.NewDPA(dpaChunkStore, self.config.ChunkerParams) self.dpa = storage.NewDPA(dpaChunkStore, self.config.ChunkerParams)
@ -212,6 +213,11 @@ func (self *Swarm) Stop() error {
ch.Stop() ch.Stop()
ch.Save() ch.Save()
} }
if self.lstore != nil {
self.lstore.DbStore.Close()
}
return self.config.Save() return self.config.Save()
} }